backendtest:Irregular HalfEllipse test via various drawing methods

Change-Id: If1a6f224f6ff4118617128630077a81da4c469a1
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/118656
Reviewed-by: Tomaž Vajngerl <quikee@gmail.com>
Tested-by: Jenkins

7 files changed, 553 insertions, 251 deletions

diff --git a/vcl/backendtest/GraphicsRenderTests.cxx b/vcl/backendtest/GraphicsRenderTests.cxx
index eae05149840b..707938cb1902 100644
--- a/vcl/backendtest/GraphicsRenderTests.cxx
+++ b/vcl/backendtest/GraphicsRenderTests.cxx
@@ -53,19 +53,19 @@ void GraphicsRenderTests::testDrawRectWithRectangle()
     vcl::test::OutputDeviceTestRect aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(false);
     m_aCurGraphicsBackend = aOutDevTest.getRenderBackendName();
-    OUString atestName = "testDrawRectWithRectangle";
+    OUString aTestName = "testDrawRectWithRectangle";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestCommon::checkRectangle(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -73,19 +73,19 @@ void GraphicsRenderTests::testDrawRectWithPixel()
 {
     vcl::test::OutputDeviceTestPixel aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(false);
-    OUString atestName = "testDrawRectWithPixel";
+    OUString aTestName = "testDrawRectWithPixel";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestCommon::checkRectangle(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -93,19 +93,19 @@ void GraphicsRenderTests::testDrawRectWithLine()
 {
     vcl::test::OutputDeviceTestLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(false);
-    OUString atestName = "testDrawRectWithLine";
+    OUString aTestName = "testDrawRectWithLine";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestCommon::checkRectangle(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -113,19 +113,19 @@ void GraphicsRenderTests::testDrawRectWithPolygon()
 {
     vcl::test::OutputDeviceTestPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(false);
-    OUString atestName = "testDrawRectWithPolygon";
+    OUString aTestName = "testDrawRectWithPolygon";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestCommon::checkRectangle(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -133,19 +133,19 @@ void GraphicsRenderTests::testDrawRectWithPolyLine()
 {
     vcl::test::OutputDeviceTestPolyLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(false);
-    OUString atestName = "testDrawRectWithPolyLine";
+    OUString aTestName = "testDrawRectWithPolyLine";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestCommon::checkRectangle(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -153,19 +153,19 @@ void GraphicsRenderTests::testDrawRectWithPolyLineB2D()
 {
     vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(false);
-    OUString atestName = "testDrawRectWithPolyLineB2D";
+    OUString aTestName = "testDrawRectWithPolyLineB2D";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestCommon::checkRectangle(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -173,19 +173,19 @@ void GraphicsRenderTests::testDrawRectWithPolyPolygon()
 {
     vcl::test::OutputDeviceTestPolyPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(false);
-    OUString atestName = "testDrawRectWithPolyPolygon";
+    OUString aTestName = "testDrawRectWithPolyPolygon";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestCommon::checkRectangle(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -193,19 +193,19 @@ void GraphicsRenderTests::testDrawRectWithPolyPolygonB2D()
 {
     vcl::test::OutputDeviceTestPolyPolygonB2D aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(false);
-    OUString atestName = "testDrawRectWithPolyPolygonB2D";
+    OUString aTestName = "testDrawRectWithPolyPolygonB2D";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestCommon::checkRectangle(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -213,19 +213,19 @@ void GraphicsRenderTests::testDrawRectAAWithRectangle()
 {
     vcl::test::OutputDeviceTestRect aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(true);
-    OUString atestName = "testDrawRectAAWithRectangle";
+    OUString aTestName = "testDrawRectAAWithRectangle";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestCommon::checkRectangleAA(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -233,19 +233,19 @@ void GraphicsRenderTests::testDrawRectAAWithPixel()
 {
     vcl::test::OutputDeviceTestPixel aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(true);
-    OUString atestName = "testDrawRectAAWithPixel";
+    OUString aTestName = "testDrawRectAAWithPixel";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestCommon::checkRectangleAA(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -253,19 +253,19 @@ void GraphicsRenderTests::testDrawRectAAWithLine()
 {
     vcl::test::OutputDeviceTestLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(true);
-    OUString atestName = "testDrawRectAAWithLine";
+    OUString aTestName = "testDrawRectAAWithLine";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestCommon::checkRectangleAA(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -273,19 +273,19 @@ void GraphicsRenderTests::testDrawRectAAWithPolygon()
 {
     vcl::test::OutputDeviceTestPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(true);
-    OUString atestName = "testDrawRectAAWithPolygon";
+    OUString aTestName = "testDrawRectAAWithPolygon";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestCommon::checkRectangleAA(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -293,19 +293,19 @@ void GraphicsRenderTests::testDrawRectAAWithPolyLine()
 {
     vcl::test::OutputDeviceTestPolyLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(true);
-    OUString atestName = "testDrawRectAAWithPolyLine";
+    OUString aTestName = "testDrawRectAAWithPolyLine";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestCommon::checkRectangleAA(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -313,19 +313,19 @@ void GraphicsRenderTests::testDrawRectAAWithPolyLineB2D()
 {
     vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(true);
-    OUString atestName = "testDrawRectAAWithPolyLineB2D";
+    OUString aTestName = "testDrawRectAAWithPolyLineB2D";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestCommon::checkRectangleAA(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -333,19 +333,19 @@ void GraphicsRenderTests::testDrawRectAAWithPolyPolygon()
 {
     vcl::test::OutputDeviceTestPolyPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(true);
-    OUString atestName = "testDrawRectAAWithPolyPolygon";
+    OUString aTestName = "testDrawRectAAWithPolyPolygon";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestCommon::checkRectangleAA(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -353,19 +353,19 @@ void GraphicsRenderTests::testDrawRectAAWithPolyPolygonB2D()
 {
     vcl::test::OutputDeviceTestPolyPolygonB2D aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(true);
-    OUString atestName = "testDrawRectAAWithPolyPolygonB2D";
+    OUString aTestName = "testDrawRectAAWithPolyPolygonB2D";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestCommon::checkRectangleAA(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -373,30 +373,30 @@ void GraphicsRenderTests::testDrawFilledRectWithRectangle()
 {
     vcl::test::OutputDeviceTestRect aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupFilledRectangle(false);
-    OUString atestName = "testDrawFilledRectWithRectangle";
+    OUString aTestName = "testDrawFilledRectWithRectangle";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult
         = vcl::test::OutputDeviceTestCommon::checkFilledRectangle(aBitmap, false);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
-    atestName += "WithAA";
+    aTestName += "WithAA";
     aBitmap = aOutDevTest.setupFilledRectangle(true);
     eResult = vcl::test::OutputDeviceTestCommon::checkFilledRectangle(aBitmap, true);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -404,30 +404,30 @@ void GraphicsRenderTests::testDrawFilledRectWithPolygon()
 {
     vcl::test::OutputDeviceTestPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupFilledRectangle(false);
-    OUString atestName = "testDrawFilledRectWithPolygon";
+    OUString aTestName = "testDrawFilledRectWithPolygon";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult
         = vcl::test::OutputDeviceTestCommon::checkFilledRectangle(aBitmap, false);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
-    atestName += "WithAA";
+    aTestName += "WithAA";
     aBitmap = aOutDevTest.setupFilledRectangle(true);
     eResult = vcl::test::OutputDeviceTestCommon::checkFilledRectangle(aBitmap, true);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -435,30 +435,30 @@ void GraphicsRenderTests::testDrawFilledRectWithPolyPolygon()
 {
     vcl::test::OutputDeviceTestPolyPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupFilledRectangle(false);
-    OUString atestName = "testDrawFilledRectWithPolyPolygon";
+    OUString aTestName = "testDrawFilledRectWithPolyPolygon";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult
         = vcl::test::OutputDeviceTestCommon::checkFilledRectangle(aBitmap, false);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
-    atestName += "WithAA";
+    aTestName += "WithAA";
     aBitmap = aOutDevTest.setupFilledRectangle(true);
     eResult = vcl::test::OutputDeviceTestCommon::checkFilledRectangle(aBitmap, true);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -466,30 +466,30 @@ void GraphicsRenderTests::testDrawFilledRectWithPolyPolygon2D()
 {
     vcl::test::OutputDeviceTestPolyPolygonB2D aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupFilledRectangle(false);
-    OUString atestName = "testDrawFilledRectWithPolyPolygon2D";
+    OUString aTestName = "testDrawFilledRectWithPolyPolygon2D";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult
         = vcl::test::OutputDeviceTestCommon::checkFilledRectangle(aBitmap, false);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
-    atestName += "WithAA";
+    aTestName += "WithAA";
     aBitmap = aOutDevTest.setupFilledRectangle(true);
     eResult = vcl::test::OutputDeviceTestCommon::checkFilledRectangle(aBitmap, true);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -497,19 +497,19 @@ void GraphicsRenderTests::testDrawDiamondWithPolygon()
 {
     vcl::test::OutputDeviceTestPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupDiamond();
-    OUString atestName = "testDrawDiamondWithPolygon";
+    OUString aTestName = "testDrawDiamondWithPolygon";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestCommon::checkDiamond(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -517,19 +517,19 @@ void GraphicsRenderTests::testDrawDiamondWithLine()
 {
     vcl::test::OutputDeviceTestLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupDiamond();
-    OUString atestName = "testDrawDiamondWithLine";
+    OUString aTestName = "testDrawDiamondWithLine";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestCommon::checkDiamond(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -537,19 +537,19 @@ void GraphicsRenderTests::testDrawDiamondWithPolyline()
 {
     vcl::test::OutputDeviceTestPolyLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupDiamond();
-    OUString atestName = "testDrawDiamondWithPolyline";
+    OUString aTestName = "testDrawDiamondWithPolyline";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestCommon::checkDiamond(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -557,19 +557,19 @@ void GraphicsRenderTests::testDrawDiamondWithPolylineB2D()
 {
     vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupDiamond();
-    OUString atestName = "testDrawDiamondWithPolylineB2D";
+    OUString aTestName = "testDrawDiamondWithPolylineB2D";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestCommon::checkDiamond(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -577,20 +577,20 @@ void GraphicsRenderTests::testDrawInvertWithRectangle()
 {
     vcl::test::OutputDeviceTestRect aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupInvert_NONE();
-    OUString atestName = "testDrawInvertWithRectangle";
+    OUString aTestName = "testDrawInvertWithRectangle";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult
         = vcl::test::OutputDeviceTestCommon::checkInvertRectangle(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -598,20 +598,20 @@ void GraphicsRenderTests::testDrawInvertN50WithRectangle()
 {
     vcl::test::OutputDeviceTestRect aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupInvert_N50();
-    OUString atestName = "testDrawInvertN50WithRectangle";
+    OUString aTestName = "testDrawInvertN50WithRectangle";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult
         = vcl::test::OutputDeviceTestCommon::checkInvertN50Rectangle(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -619,20 +619,20 @@ void GraphicsRenderTests::testDrawInvertTrackFrameWithRectangle()
 {
     vcl::test::OutputDeviceTestRect aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupInvert_TrackFrame();
-    OUString atestName = "testDrawInvertTrackFrameWithRectangle";
+    OUString aTestName = "testDrawInvertTrackFrameWithRectangle";
     if (!(SHOULD_ASSERT && aOutDevTest.getRenderBackendName() != "svp"))
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult
         = vcl::test::OutputDeviceTestCommon::checkInvertTrackFrameRectangle(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -640,19 +640,19 @@ void GraphicsRenderTests::testDrawDropShapeWithPolyline()
 {
     vcl::test::OutputDeviceTestPolyLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupDropShape();
-    OUString atestName = "testDrawDropShapeWithPolyline";
+    OUString aTestName = "testDrawDropShapeWithPolyline";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestCommon::checkDropShape(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -660,20 +660,20 @@ void GraphicsRenderTests::testDrawDropShapeAAWithPolyline()
 {
     vcl::test::OutputDeviceTestPolyLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupAADropShape();
-    OUString atestName = "testDrawDropShapeAAWithPolyline";
+    OUString aTestName = "testDrawDropShapeAAWithPolyline";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult
         = vcl::test::OutputDeviceTestCommon::checkDropShape(aBitmap, true);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -681,19 +681,19 @@ void GraphicsRenderTests::testDrawBezierWithPolylineB2D()
 {
     vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupBezier();
-    OUString atestName = "testDrawBezierWithPolylineB2D";
+    OUString aTestName = "testDrawBezierWithPolylineB2D";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestCommon::checkBezier(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -701,19 +701,19 @@ void GraphicsRenderTests::testDrawBezierAAWithPolylineB2D()
 {
     vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupAABezier();
-    OUString atestName = "testDrawBezierAAWithPolylineB2D";
+    OUString aTestName = "testDrawBezierAAWithPolylineB2D";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestCommon::checkBezier(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -721,19 +721,19 @@ void GraphicsRenderTests::testDrawDropShapeWithPolygon()
 {
     vcl::test::OutputDeviceTestPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupDropShape();
-    OUString atestName = "testDrawDropShapeWithPolygon";
+    OUString aTestName = "testDrawDropShapeWithPolygon";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestCommon::checkDropShape(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -741,20 +741,20 @@ void GraphicsRenderTests::testDrawDropShapeAAWithPolygon()
 {
     vcl::test::OutputDeviceTestPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupAADropShape();
-    OUString atestName = "testDrawDropShapeAAWithPolygon";
+    OUString aTestName = "testDrawDropShapeAAWithPolygon";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult
         = vcl::test::OutputDeviceTestCommon::checkDropShape(aBitmap, true);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -762,20 +762,20 @@ void GraphicsRenderTests::testDrawBitmap()
 {
     vcl::test::OutputDeviceTestBitmap aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupDrawBitmap();
-    OUString atestName = "testDrawBitmap";
+    OUString aTestName = "testDrawBitmap";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult
         = vcl::test::OutputDeviceTestBitmap::checkTransformedBitmap(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -783,20 +783,20 @@ void GraphicsRenderTests::testDrawTransformedBitmap()
 {
     vcl::test::OutputDeviceTestBitmap aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupDrawTransformedBitmap();
-    OUString atestName = "testDrawTransformedBitmap";
+    OUString aTestName = "testDrawTransformedBitmap";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult
         = vcl::test::OutputDeviceTestBitmap::checkTransformedBitmap(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -804,20 +804,20 @@ void GraphicsRenderTests::testDrawBitmapExWithAlpha()
 {
     vcl::test::OutputDeviceTestBitmap aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupDrawBitmapExWithAlpha();
-    OUString atestName = "testDrawBitmapExWithAlpha";
+    OUString aTestName = "testDrawBitmapExWithAlpha";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult
         = vcl::test::OutputDeviceTestBitmap::checkBitmapExWithAlpha(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -825,19 +825,19 @@ void GraphicsRenderTests::testDrawMask()
 {
     vcl::test::OutputDeviceTestBitmap aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupDrawMask();
-    OUString atestName = "testDrawMask";
+    OUString aTestName = "testDrawMask";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestBitmap::checkMask(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -845,18 +845,18 @@ void GraphicsRenderTests::testDrawBlend()
 {
     vcl::test::OutputDeviceTestBitmap aOutDevTest;
     BitmapEx aBitmapEx = aOutDevTest.setupDrawBlend();
-    OUString atestName = "testDrawBlend";
+    OUString aTestName = "testDrawBlend";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestBitmap::checkBlend(aBitmapEx);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmapEx.GetBitmap() : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -864,19 +864,19 @@ void GraphicsRenderTests::testDrawXor()
 {
     vcl::test::OutputDeviceTestAnotherOutDev aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupXOR();
-    OUString atestName = "testDrawXor";
+    OUString aTestName = "testDrawXor";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestAnotherOutDev::checkXOR(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -884,19 +884,19 @@ void GraphicsRenderTests::testClipRectangle()
 {
     vcl::test::OutputDeviceTestClip aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupClipRectangle();
-    OUString atestName = "testClipRectangle";
+    OUString aTestName = "testClipRectangle";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestClip::checkClip(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -904,19 +904,19 @@ void GraphicsRenderTests::testClipPolygon()
 {
     vcl::test::OutputDeviceTestClip aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupClipPolygon();
-    OUString atestName = "testClipPolygon";
+    OUString aTestName = "testClipPolygon";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestClip::checkClip(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -924,19 +924,19 @@ void GraphicsRenderTests::testClipPolyPolygon()
 {
     vcl::test::OutputDeviceTestClip aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupClipPolyPolygon();
-    OUString atestName = "testClipPolyPolygon";
+    OUString aTestName = "testClipPolyPolygon";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestClip::checkClip(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -944,19 +944,19 @@ void GraphicsRenderTests::testClipB2DPolyPolygon()
 {
     vcl::test::OutputDeviceTestClip aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupClipB2DPolyPolygon();
-    OUString atestName = "testClipB2DPolyPolygon";
+    OUString aTestName = "testClipB2DPolyPolygon";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestClip::checkClip(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -964,20 +964,20 @@ void GraphicsRenderTests::testDrawOutDev()
 {
     vcl::test::OutputDeviceTestAnotherOutDev aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupDrawOutDev();
-    OUString atestName = "testDrawOutDev";
+    OUString aTestName = "testDrawOutDev";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult
         = vcl::test::OutputDeviceTestAnotherOutDev::checkDrawOutDev(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -985,19 +985,19 @@ void GraphicsRenderTests::testDashedLine()
 {
     vcl::test::OutputDeviceTestLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupDashedLine();
-    OUString atestName = "testDashedLine";
+    OUString aTestName = "testDashedLine";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestLine::checkDashedLine(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -1005,20 +1005,20 @@ void GraphicsRenderTests::testLinearGradient()
 {
     vcl::test::OutputDeviceTestGradient aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupLinearGradient();
-    OUString atestName = "testLinearGradient";
+    OUString aTestName = "testLinearGradient";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult
         = vcl::test::OutputDeviceTestGradient::checkLinearGradient(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -1026,20 +1026,20 @@ void GraphicsRenderTests::testLinearGradientAngled()
 {
     vcl::test::OutputDeviceTestGradient aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupLinearGradientAngled();
-    OUString atestName = "testLinearGradientAngled";
+    OUString aTestName = "testLinearGradientAngled";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult
         = vcl::test::OutputDeviceTestGradient::checkLinearGradientAngled(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -1047,20 +1047,20 @@ void GraphicsRenderTests::testLinearGradientBorder()
 {
     vcl::test::OutputDeviceTestGradient aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupLinearGradientBorder();
-    OUString atestName = "testLinearGradientBorder";
+    OUString aTestName = "testLinearGradientBorder";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult
         = vcl::test::OutputDeviceTestGradient::checkLinearGradientBorder(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -1068,20 +1068,20 @@ void GraphicsRenderTests::testLinearGradientIntensity()
 {
     vcl::test::OutputDeviceTestGradient aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupLinearGradientIntensity();
-    OUString atestName = "testLinearGradientIntensity";
+    OUString aTestName = "testLinearGradientIntensity";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult
         = vcl::test::OutputDeviceTestGradient::checkLinearGradientIntensity(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -1089,20 +1089,20 @@ void GraphicsRenderTests::testLinearGradientSteps()
 {
     vcl::test::OutputDeviceTestGradient aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupLinearGradientSteps();
-    OUString atestName = "testLinearGradientSteps";
+    OUString aTestName = "testLinearGradientSteps";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult
         = vcl::test::OutputDeviceTestGradient::checkLinearGradientSteps(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -1110,20 +1110,20 @@ void GraphicsRenderTests::testAxialGradient()
 {
     vcl::test::OutputDeviceTestGradient aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupAxialGradient();
-    OUString atestName = "testAxialGradient";
+    OUString aTestName = "testAxialGradient";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult
         = vcl::test::OutputDeviceTestGradient::checkAxialGradient(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -1131,20 +1131,20 @@ void GraphicsRenderTests::testRadialGradient()
 {
     vcl::test::OutputDeviceTestGradient aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRadialGradient();
-    OUString atestName = "testRadialGradient";
+    OUString aTestName = "testRadialGradient";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult
         = vcl::test::OutputDeviceTestGradient::checkRadialGradient(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -1152,15 +1152,15 @@ void GraphicsRenderTests::testRadialGradientOfs()
 {
     vcl::test::OutputDeviceTestGradient aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRadialGradientOfs();
-    OUString atestName = "testRadialGradientOfs";
+    OUString aTestName = "testRadialGradientOfs";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult
         = vcl::test::OutputDeviceTestGradient::checkRadialGradientOfs(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
 }
 
@@ -1168,19 +1168,19 @@ void GraphicsRenderTests::testLineJoinBevel()
 {
     vcl::test::OutputDeviceTestLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupLineJoinBevel();
-    OUString atestName = "testLineJoinBevel";
+    OUString aTestName = "testLineJoinBevel";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestLine::checkLineJoinBevel(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -1188,19 +1188,19 @@ void GraphicsRenderTests::testLineJoinRound()
 {
     vcl::test::OutputDeviceTestLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupLineJoinRound();
-    OUString atestName = "testLineJoinRound";
+    OUString aTestName = "testLineJoinRound";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestLine::checkLineJoinRound(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -1208,19 +1208,19 @@ void GraphicsRenderTests::testLineJoinMiter()
 {
     vcl::test::OutputDeviceTestLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupLineJoinMiter();
-    OUString atestName = "testLineJoinMiter";
+    OUString aTestName = "testLineJoinMiter";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestLine::checkLineJoinMiter(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -1228,19 +1228,19 @@ void GraphicsRenderTests::testLineJoinNone()
 {
     vcl::test::OutputDeviceTestLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupLineJoinNone();
-    OUString atestName = "testLineJoinNone";
+    OUString aTestName = "testLineJoinNone";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestLine::checkLineJoinNone(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -1248,19 +1248,19 @@ void GraphicsRenderTests::testLineCapRound()
 {
     vcl::test::OutputDeviceTestLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupLineCapRound();
-    OUString atestName = "testLineCapRound";
+    OUString aTestName = "testLineCapRound";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestLine::checkLineCapRound(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -1268,19 +1268,19 @@ void GraphicsRenderTests::testLineCapSquare()
 {
     vcl::test::OutputDeviceTestLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupLineCapSquare();
-    OUString atestName = "testLineCapSquare";
+    OUString aTestName = "testLineCapSquare";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestLine::checkLineCapSquare(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -1288,19 +1288,142 @@ void GraphicsRenderTests::testLineCapButt()
 {
     vcl::test::OutputDeviceTestLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupLineCapButt();
-    OUString atestName = "testLineCapButt";
+    OUString aTestName = "testLineCapButt";
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(atestName, "SKIPPED");
+        appendTestResult(aTestName, "SKIPPED");
         return;
     }
     vcl::test::TestResult eResult = vcl::test::OutputDeviceTestLine::checkLineCapButt(aBitmap);
-    appendTestResult(atestName, returnTestStatus(eResult),
+    appendTestResult(aTestName, returnTestStatus(eResult),
                      (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
     if (m_aStoreResultantBitmap)
     {
         BitmapEx aBitmapEx(aBitmap);
-        exportBitmapExToImage(m_aUserInstallPath + atestName + ".png", aBitmapEx);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
+    }
+}
+
+void GraphicsRenderTests::testHalfEllipseWithPolyLine()
+{
+    vcl::test::OutputDeviceTestPolyLine aOutDevTest;
+    Bitmap aBitmap = aOutDevTest.setupHalfEllipse();
+    OUString aTestName = "testHalfEllipseWithPolyLine";
+    if (!SHOULD_ASSERT)
+    {
+        appendTestResult(aTestName, "SKIPPED");
+        return;
+    }
+    vcl::test::TestResult eResult = vcl::test::OutputDeviceTestLine::checkHalfEllipse(aBitmap);
+    appendTestResult(aTestName, returnTestStatus(eResult),
+                     (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
+    if (m_aStoreResultantBitmap)
+    {
+        BitmapEx aBitmapEx(aBitmap);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
+    }
+}
+
+void GraphicsRenderTests::testHalfEllipseAAWithPolyLine()
+{
+    vcl::test::OutputDeviceTestPolyLine aOutDevTest;
+    Bitmap aBitmap = aOutDevTest.setupHalfEllipse(true);
+    OUString aTestName = "testHalfEllipseAAWithPolyLine";
+    if (!SHOULD_ASSERT)
+    {
+        appendTestResult(aTestName, "SKIPPED");
+        return;
+    }
+    vcl::test::TestResult eResult
+        = vcl::test::OutputDeviceTestLine::checkHalfEllipse(aBitmap, true);
+    appendTestResult(aTestName, returnTestStatus(eResult),
+                     (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
+    if (m_aStoreResultantBitmap)
+    {
+        BitmapEx aBitmapEx(aBitmap);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
+    }
+}
+
+void GraphicsRenderTests::testHalfEllipseWithPolyLineB2D()
+{
+    vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
+    Bitmap aBitmap = aOutDevTest.setupHalfEllipse();
+    OUString aTestName = "testHalfEllipseWithPolyLineB2D";
+    if (!SHOULD_ASSERT)
+    {
+        appendTestResult(aTestName, "SKIPPED");
+        return;
+    }
+    vcl::test::TestResult eResult = vcl::test::OutputDeviceTestLine::checkHalfEllipse(aBitmap);
+    appendTestResult(aTestName, returnTestStatus(eResult),
+                     (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
+    if (m_aStoreResultantBitmap)
+    {
+        BitmapEx aBitmapEx(aBitmap);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
+    }
+}
+
+void GraphicsRenderTests::testHalfEllipseAAWithPolyLineB2D()
+{
+    vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
+    Bitmap aBitmap = aOutDevTest.setupHalfEllipse(true);
+    OUString aTestName = "testHalfEllipseAAWithPolyLineB2D";
+    if (!SHOULD_ASSERT)
+    {
+        appendTestResult(aTestName, "SKIPPED");
+        return;
+    }
+    vcl::test::TestResult eResult
+        = vcl::test::OutputDeviceTestLine::checkHalfEllipse(aBitmap, true);
+    appendTestResult(aTestName, returnTestStatus(eResult),
+                     (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
+    if (m_aStoreResultantBitmap)
+    {
+        BitmapEx aBitmapEx(aBitmap);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
+    }
+}
+
+void GraphicsRenderTests::testHalfEllipseWithPolygon()
+{
+    vcl::test::OutputDeviceTestPolygon aOutDevTest;
+    Bitmap aBitmap = aOutDevTest.setupHalfEllipse();
+    OUString aTestName = "testHalfEllipseWithPolygon";
+    if (!SHOULD_ASSERT)
+    {
+        appendTestResult(aTestName, "SKIPPED");
+        return;
+    }
+    vcl::test::TestResult eResult = vcl::test::OutputDeviceTestLine::checkHalfEllipse(aBitmap);
+    appendTestResult(aTestName, returnTestStatus(eResult),
+                     (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
+    if (m_aStoreResultantBitmap)
+    {
+        BitmapEx aBitmapEx(aBitmap);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
+    }
+}
+
+void GraphicsRenderTests::testHalfEllipseAAWithPolygon()
+{
+    vcl::test::OutputDeviceTestPolygon aOutDevTest;
+    Bitmap aBitmap = aOutDevTest.setupHalfEllipse(true);
+    OUString aTestName = "testHalfEllipseAAWithPolygon";
+    if (!SHOULD_ASSERT)
+    {
+        appendTestResult(aTestName, "SKIPPED");
+        return;
+    }
+    vcl::test::TestResult eResult
+        = vcl::test::OutputDeviceTestLine::checkHalfEllipse(aBitmap, true);
+    appendTestResult(aTestName, returnTestStatus(eResult),
+                     (m_aStoreResultantBitmap ? aBitmap : Bitmap()));
+    if (m_aStoreResultantBitmap)
+    {
+        BitmapEx aBitmapEx(aBitmap);
+        exportBitmapExToImage(m_aUserInstallPath + aTestName + ".png", aBitmapEx);
     }
 }
 
@@ -1366,6 +1489,12 @@ void GraphicsRenderTests::runALLTests()
     testDrawDropShapeAAWithPolyline();
     testDrawDropShapeWithPolygon();
     testDrawDropShapeAAWithPolygon();
+    testHalfEllipseWithPolyLine();
+    testHalfEllipseAAWithPolyLine();
+    testHalfEllipseWithPolyLineB2D();
+    testHalfEllipseAAWithPolyLineB2D();
+    testHalfEllipseWithPolygon();
+    testHalfEllipseAAWithPolygon();
 }
 
 void GraphicsRenderTests::appendTestResult(OUString aTestName, OUString aTestStatus,
diff --git a/vcl/backendtest/outputdevice/common.cxx b/vcl/backendtest/outputdevice/common.cxx
index 65507abe018a..570ddb49c544 100644
--- a/vcl/backendtest/outputdevice/common.cxx
+++ b/vcl/backendtest/outputdevice/common.cxx
@@ -579,6 +579,21 @@ tools::Polygon OutputDeviceTestCommon::createDropShapePolygon()
     return aPolygon;
 }
 
+basegfx::B2DPolygon OutputDeviceTestCommon::createHalfEllipsePolygon()
+{
+    basegfx::B2DPolygon aPolygon;
+
+    aPolygon.append({ 9.0, 1.0 });
+    aPolygon.append({ 17.0, 10.0 });
+    aPolygon.append({ 1.0, 10.0 });
+    aPolygon.setClosed(true);
+
+    aPolygon.setControlPoints(0, { 1.5, 1.5 }, { 16.5, 1.5 });
+
+    return aPolygon;
+}
+
+
 TestResult OutputDeviceTestCommon::checkDropShape(Bitmap& rBitmap, bool aEnableAA)
 {
     BitmapScopedWriteAccess pAccess(rBitmap);
@@ -659,6 +674,55 @@ TestResult OutputDeviceTestCommon::checkBezier(Bitmap& rBitmap)
     return checkRectangles(rBitmap, aExpected);
 }
 
+TestResult OutputDeviceTestCommon::checkHalfEllipse(Bitmap& rBitmap, bool aEnableAA)
+{
+    BitmapScopedWriteAccess pAccess(rBitmap);
+
+    TestResult aResult = TestResult::Passed;
+    int nNumberOfQuirks = 0;
+    int nNumberOfErrors = 0;
+
+    std::map<std::pair<tools::Long, tools::Long>, bool> SetPixels = {
+        { { 8, 1 }, true },   { { 9, 1 }, true },   { { 10, 1 }, true },  { { 6, 2 }, true },
+        { { 7, 2 }, true },   { { 10, 2 }, true },  { { 4, 3 }, true },   { { 5, 3 }, true },
+        { { 10, 3 }, true },  { { 3, 4 }, true },   { { 10, 4 }, true },  { { 2, 5 }, true },
+        { { 10, 5 }, true },  { { 2, 6 }, true },   { { 10, 6 }, true },  { { 1, 7 }, true },
+        { { 10, 7 }, true },  { { 1, 8 }, true },   { { 10, 8 }, true },  { { 1, 9 }, true },
+        { { 10, 9 }, true },  { { 1, 10 }, true },  { { 10, 10 }, true }, { { 1, 11 }, true },
+        { { 10, 11 }, true }, { { 2, 12 }, true },  { { 10, 12 }, true }, { { 2, 13 }, true },
+        { { 10, 13 }, true }, { { 3, 14 }, true },  { { 10, 14 }, true }, { { 4, 15 }, true },
+        { { 5, 15 }, true },  { { 10, 15 }, true }, { { 6, 16 }, true },  { { 7, 16 }, true },
+        { { 10, 16 }, true }, { { 8, 17 }, true },  { { 9, 17 }, true },  { { 10, 17 }, true }
+    };
+
+    for (tools::Long x = 0; x < pAccess->Width(); x++)
+    {
+        for (tools::Long y = 0; y < pAccess->Height(); ++y)
+        {
+            if (SetPixels[{ y, x }])
+            {
+                if (aEnableAA)
+                    checkValueAA(pAccess, x, y, constLineColor, nNumberOfQuirks, nNumberOfErrors);
+                else
+                    checkValue(pAccess, x, y, constLineColor, nNumberOfQuirks, nNumberOfErrors,
+                               true);
+            }
+            else
+            {
+                if (!aEnableAA)
+                    checkValue(pAccess, x, y, constBackgroundColor, nNumberOfQuirks,
+                               nNumberOfErrors, true);
+            }
+        }
+    }
+
+    if (nNumberOfQuirks > 0)
+        aResult = TestResult::PassedWithQuirks;
+    if (nNumberOfErrors > 0)
+        aResult = TestResult::Failed;
+    return aResult;
+}
+
 // Check 'count' pixels from (x,y) in (addX,addY) direction, the color values must not decrease.
 static bool checkGradient(BitmapScopedWriteAccess& pAccess, int x, int y, int count, int addX, int addY)
 {
diff --git a/vcl/backendtest/outputdevice/polygon.cxx b/vcl/backendtest/outputdevice/polygon.cxx
index b3a918f29ff7..9562dfecb290 100644
--- a/vcl/backendtest/outputdevice/polygon.cxx
+++ b/vcl/backendtest/outputdevice/polygon.cxx
@@ -176,6 +176,18 @@ Bitmap OutputDeviceTestPolygon::setupAADropShape()
     return mpVirtualDevice->GetBitmap(maVDRectangle.TopLeft(), maVDRectangle.GetSize());
 }
 
+Bitmap OutputDeviceTestPolygon::setupHalfEllipse(bool aEnableAA)
+{
+    initialSetup(19, 21, constBackgroundColor, aEnableAA);
+
+    mpVirtualDevice->SetLineColor(constLineColor);
+    mpVirtualDevice->SetFillColor();
+
+    mpVirtualDevice->DrawPolyLine(
+        tools::Polygon(OutputDeviceTestCommon::createHalfEllipsePolygon()));
+
+    return mpVirtualDevice->GetBitmap(maVDRectangle.TopLeft(), maVDRectangle.GetSize());
+}
 } // end namespace vcl::test
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/backendtest/outputdevice/polyline.cxx b/vcl/backendtest/outputdevice/polyline.cxx
index db82d4f0a9d1..edaf1bf428c5 100644
--- a/vcl/backendtest/outputdevice/polyline.cxx
+++ b/vcl/backendtest/outputdevice/polyline.cxx
@@ -161,6 +161,18 @@ Bitmap OutputDeviceTestPolyLine::setupAADropShape()
     return mpVirtualDevice->GetBitmap(maVDRectangle.TopLeft(), maVDRectangle.GetSize());
 }
 
+Bitmap OutputDeviceTestPolyLine::setupHalfEllipse(bool aEnableAA)
+{
+    initialSetup(19, 21, constBackgroundColor, aEnableAA);
+
+    mpVirtualDevice->SetLineColor(constLineColor);
+    mpVirtualDevice->SetFillColor();
+
+    mpVirtualDevice->DrawPolyLine(
+        tools::Polygon(OutputDeviceTestCommon::createHalfEllipsePolygon()));
+
+    return mpVirtualDevice->GetBitmap(maVDRectangle.TopLeft(), maVDRectangle.GetSize());
+}
 } // end namespace vcl::test
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/backendtest/outputdevice/polyline_b2d.cxx b/vcl/backendtest/outputdevice/polyline_b2d.cxx
index 65658d7aeb1d..d3b4d5158007 100644
--- a/vcl/backendtest/outputdevice/polyline_b2d.cxx
+++ b/vcl/backendtest/outputdevice/polyline_b2d.cxx
@@ -122,6 +122,19 @@ Bitmap OutputDeviceTestPolyLineB2D::setupAABezier()
 
     return mpVirtualDevice->GetBitmap(maVDRectangle.TopLeft(), maVDRectangle.GetSize());
 }
+
+Bitmap OutputDeviceTestPolyLineB2D::setupHalfEllipse(bool aEnableAA)
+{
+    initialSetup(19, 21, constBackgroundColor, aEnableAA);
+
+    mpVirtualDevice->SetLineColor(constLineColor);
+    mpVirtualDevice->SetFillColor();
+
+    mpVirtualDevice->DrawPolyLine(OutputDeviceTestCommon::createHalfEllipsePolygon());
+
+    return mpVirtualDevice->GetBitmap(maVDRectangle.TopLeft(), maVDRectangle.GetSize());
+}
+
 } // end namespace vcl::test
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/inc/test/outputdevice.hxx b/vcl/inc/test/outputdevice.hxx
index d3dec05c5ebf..6e3943ef6fd6 100644
--- a/vcl/inc/test/outputdevice.hxx
+++ b/vcl/inc/test/outputdevice.hxx
@@ -68,6 +68,7 @@ public:
                                     Point& rPoint3, Point& rPoint4);
 
     static tools::Polygon createDropShapePolygon();
+    static basegfx::B2DPolygon createHalfEllipsePolygon();
 
     static void createHorizontalVerticalDiagonalLinePoints(tools::Rectangle rRect,
                                 Point& rHorizontalLinePoint1, Point& rHorizontalLinePoint2,
@@ -87,6 +88,7 @@ public:
     static TestResult checkLineJoinMiter(Bitmap& rBitmap) { return checkLineJoin(rBitmap, basegfx::B2DLineJoin::Miter); }
     static TestResult checkLineJoinNone(Bitmap& rBitmap) { return checkLineJoin(rBitmap, basegfx::B2DLineJoin::NONE); }
     static TestResult checkDropShape(Bitmap& rBitmap, bool aEnableAA = false);
+    static TestResult checkHalfEllipse(Bitmap& rBitmap, bool aEnableAA = false);
 private:
     static TestResult checkLineCap(Bitmap& rBitmap, css::drawing::LineCap lineCap);
     static TestResult checkLineJoin(Bitmap& rBitmap, basegfx::B2DLineJoin lineJoin);
@@ -166,6 +168,7 @@ public:
     Bitmap setupAALines();
     Bitmap setupDropShape();
     Bitmap setupAADropShape();
+    Bitmap setupHalfEllipse(bool aEnableAA = false);
 };
 
 class VCL_DLLPUBLIC OutputDeviceTestPolyLineB2D : public OutputDeviceTestCommon
@@ -177,6 +180,7 @@ public:
     Bitmap setupDiamond();
     Bitmap setupBezier();
     Bitmap setupAABezier();
+    Bitmap setupHalfEllipse(bool aEnableAA = false);
 };
 
 class VCL_DLLPUBLIC OutputDeviceTestRect : public OutputDeviceTestCommon
@@ -203,6 +207,7 @@ public:
     Bitmap setupAALines();
     Bitmap setupDropShape();
     Bitmap setupAADropShape();
+    Bitmap setupHalfEllipse(bool aEnableAA = false);
 };
 
 class VCL_DLLPUBLIC OutputDeviceTestPolyPolygon : public OutputDeviceTestCommon
diff --git a/vcl/qa/cppunit/BackendTest.cxx b/vcl/qa/cppunit/BackendTest.cxx
index 4f6dde7ad6a4..4e26d4aabc0d 100644
--- a/vcl/qa/cppunit/BackendTest.cxx
+++ b/vcl/qa/cppunit/BackendTest.cxx
@@ -902,6 +902,66 @@ public:
             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
     }
 
+    void testDrawHaflEllipseWithPolyLine()
+    {
+        vcl::test::OutputDeviceTestPolyLine aOutDevTest;
+        Bitmap aBitmap = aOutDevTest.setupHalfEllipse();
+        auto eResult = vcl::test::OutputDeviceTestCommon::checkHalfEllipse(aBitmap);
+        exportImage("17-01_half_ellipse_test-polyline.png", aBitmap);
+        if (SHOULD_ASSERT)
+            CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
+    }
+
+    void testDrawHaflEllipseAAWithPolyLine()
+    {
+        vcl::test::OutputDeviceTestPolyLine aOutDevTest;
+        Bitmap aBitmap = aOutDevTest.setupHalfEllipse(true);
+        auto eResult = vcl::test::OutputDeviceTestCommon::checkHalfEllipse(aBitmap, true);
+        exportImage("17-02_half_ellipse_AA_test-polyline.png", aBitmap);
+        if (SHOULD_ASSERT)
+            CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
+    }
+
+    void testDrawHaflEllipseWithPolyLineB2D()
+    {
+        vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
+        Bitmap aBitmap = aOutDevTest.setupHalfEllipse();
+        auto eResult = vcl::test::OutputDeviceTestCommon::checkHalfEllipse(aBitmap);
+        exportImage("17-03_half_ellipse_test-polylineb2d.png", aBitmap);
+        if (SHOULD_ASSERT)
+            CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
+    }
+
+    void testDrawHaflEllipseAAWithPolyLineB2D()
+    {
+        vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
+        Bitmap aBitmap = aOutDevTest.setupHalfEllipse(true);
+        auto eResult = vcl::test::OutputDeviceTestCommon::checkHalfEllipse(aBitmap, true);
+        exportImage("17-03_half_ellipse_AA_test-polylineb2d.png", aBitmap);
+        if (SHOULD_ASSERT)
+            CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
+    }
+
+    void testDrawHaflEllipseWithPolygon()
+    {
+        vcl::test::OutputDeviceTestPolyLine aOutDevTest;
+        Bitmap aBitmap = aOutDevTest.setupHalfEllipse();
+        auto eResult = vcl::test::OutputDeviceTestCommon::checkHalfEllipse(aBitmap);
+        exportImage("17-04_half_ellipse_test-polygon.png", aBitmap);
+        if (SHOULD_ASSERT)
+            CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
+    }
+
+    void testDrawHaflEllipseAAWithPolygon()
+    {
+        vcl::test::OutputDeviceTestPolyLine aOutDevTest;
+        Bitmap aBitmap = aOutDevTest.setupHalfEllipse(true);
+        auto eResult = vcl::test::OutputDeviceTestCommon::checkHalfEllipse(aBitmap, true);
+        exportImage("17-05_half_ellipse_AA_test-polygon.png", aBitmap);
+        if (SHOULD_ASSERT)
+            CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
+    }
+
     // Test SalGraphics::blendBitmap() and blendAlphaBitmap() calls.
     void testDrawBlendExtended()
     {
@@ -1127,6 +1187,13 @@ public:
     CPPUNIT_TEST(testDrawDropShapeWithPolygon);
     CPPUNIT_TEST(testDrawDropShapeAAWithPolygon);
 
+    CPPUNIT_TEST(testDrawHaflEllipseWithPolyLine);
+    CPPUNIT_TEST(testDrawHaflEllipseAAWithPolyLine);
+    CPPUNIT_TEST(testDrawHaflEllipseWithPolyLineB2D);
+    CPPUNIT_TEST(testDrawHaflEllipseAAWithPolyLineB2D);
+    CPPUNIT_TEST(testDrawHaflEllipseWithPolygon);
+    CPPUNIT_TEST(testDrawHaflEllipseAAWithPolygon);
+
     CPPUNIT_TEST(testDrawBitmap);
     CPPUNIT_TEST(testDrawTransformedBitmap);
     CPPUNIT_TEST(testDrawBitmapExWithAlpha);