include/vcl/textfilter.hxx                                 |    2 
 include/vcl/weldutils.hxx                                  |    4 
 vcl/backendtest/GraphicsRenderTests.cxx                    |  440 ++++++-------
 vcl/backendtest/VisualBackendTest.cxx                      |    4 
 vcl/backendtest/outputdevice/text.cxx                      |    4 
 vcl/headless/svpframe.cxx                                  |    2 
 vcl/headless/svpprn.cxx                                    |    4 
 vcl/inc/font/FontSelectPattern.hxx                         |    2 
 vcl/inc/headless/SvpGraphicsBackend.hxx                    |    2 
 vcl/inc/qt5/QtGraphics.hxx                                 |    2 
 vcl/inc/qt5/QtSvpGraphics.hxx                              |    2 
 vcl/inc/salinst.hxx                                        |    2 
 vcl/inc/skia/gdiimpl.hxx                                   |    2 
 vcl/inc/unx/gtk/gtkgdi.hxx                                 |    2 
 vcl/inc/vclstatuslistener.hxx                              |    2 
 vcl/jsdialog/executor.cxx                                  |   76 +-
 vcl/jsdialog/jsdialogbuilder.cxx                           |   26 
 vcl/qa/api/XGraphicTest.cxx                                |   42 -
 vcl/qa/cppunit/BackendTest.cxx                             |  234 +++---
 vcl/qa/cppunit/BitmapFilterTest.cxx                        |   18 
 vcl/qa/cppunit/BitmapScaleTest.cxx                         |   18 
 vcl/qa/cppunit/FontFeatureTest.cxx                         |   34 -
 vcl/qa/cppunit/GraphicFormatDetectorTest.cxx               |   86 +-
 vcl/qa/cppunit/GraphicTest.cxx                             |   34 -
 vcl/qa/cppunit/PDFiumLibraryTest.cxx                       |   32 
 vcl/qa/cppunit/VectorGraphicSearchTest.cxx                 |   32 
 vcl/qa/cppunit/app/test_IconThemeInfo.cxx                  |    6 
 vcl/qa/cppunit/app/test_IconThemeScanner.cxx               |    8 
 vcl/qa/cppunit/app/test_IconThemeSelector.cxx              |   34 -
 vcl/qa/cppunit/blocklistparsertest.cxx                     |   34 -
 vcl/qa/cppunit/cjktext.cxx                                 |   14 
 vcl/qa/cppunit/complextext.cxx                             |   22 
 vcl/qa/cppunit/errorhandler.cxx                            |    4 
 vcl/qa/cppunit/filter/ipdf/ipdf.cxx                        |   11 
 vcl/qa/cppunit/font.cxx                                    |    8 
 vcl/qa/cppunit/gen/gen.cxx                                 |    4 
 vcl/qa/cppunit/graphicfilter/filters-pict-test.cxx         |    8 
 vcl/qa/cppunit/graphicfilter/filters-test.cxx              |    6 
 vcl/qa/cppunit/graphicfilter/filters-tiff-test.cxx         |    2 
 vcl/qa/cppunit/graphicfilter/filters-webp-test.cxx         |    6 
 vcl/qa/cppunit/jpeg/JpegWriterTest.cxx                     |    2 
 vcl/qa/cppunit/logicalfontinstance.cxx                     |    2 
 vcl/qa/cppunit/mnemonic.cxx                                |   34 -
 vcl/qa/cppunit/outdev.cxx                                  |    4 
 vcl/qa/cppunit/pdfexport/pdfexport.cxx                     |   88 +-
 vcl/qa/cppunit/pdfexport/pdfexport2.cxx                    |  261 +++----
 vcl/qa/cppunit/physicalfontcollection.cxx                  |  101 +-
 vcl/qa/cppunit/physicalfontface.cxx                        |   42 -
 vcl/qa/cppunit/physicalfontfamily.cxx                      |   38 -
 vcl/qa/cppunit/png/PngFilterTest.cxx                       |   40 -
 vcl/qa/cppunit/text.cxx                                    |   70 +-
 vcl/qa/cppunit/textlayout.cxx                              |   12 
 vcl/qa/cppunit/widgetdraw/WidgetDefinitionReaderTest.cxx   |   16 
 vcl/qt5/QtClipboard.cxx                                    |    7 
 vcl/qt5/QtDragAndDrop.cxx                                  |   20 
 vcl/qt5/QtFilePicker.cxx                                   |   14 
 vcl/qt5/QtFrame.cxx                                        |    8 
 vcl/qt5/QtInstance.cxx                                     |    2 
 vcl/skia/SkiaHelper.cxx                                    |   22 
 vcl/source/accessibility/AccessibleTextAttributeHelper.cxx |   32 
 vcl/source/app/IconThemeSelector.cxx                       |    4 
 vcl/source/app/brand.cxx                                   |    4 
 vcl/source/app/salplug.cxx                                 |    4 
 vcl/source/app/salvtables.cxx                              |   40 -
 vcl/source/app/session.cxx                                 |    4 
 vcl/source/app/settings.cxx                                |   26 
 vcl/source/app/svapp.cxx                                   |    6 
 vcl/source/app/svdata.cxx                                  |    2 
 vcl/source/app/svmain.cxx                                  |    2 
 vcl/source/app/weldutils.cxx                               |    6 
 vcl/source/cnttype/mcnttfactory.cxx                        |    4 
 vcl/source/components/dtranscomp.cxx                       |   24 
 vcl/source/components/fontident.cxx                        |    4 
 vcl/source/control/NotebookbarPopup.cxx                    |    4 
 vcl/source/control/WeldedTabbedNotebookbar.cxx             |    4 
 vcl/source/control/button.cxx                              |    8 
 vcl/source/control/calendar.cxx                            |   18 
 vcl/source/control/edit.cxx                                |    2 
 vcl/source/control/field2.cxx                              |    2 
 vcl/source/control/imivctl1.cxx                            |    2 
 vcl/source/control/managedmenubutton.cxx                   |    8 
 vcl/source/control/menubtn.cxx                             |    6 
 vcl/source/control/notebookbar.cxx                         |    6 
 vcl/source/control/roadmap.cxx                             |    6 
 vcl/source/control/roadmapwizard.cxx                       |    4 
 vcl/source/control/tabctrl.cxx                             |    2 
 vcl/source/control/throbber.cxx                            |    2 
 vcl/source/control/wizardmachine.cxx                       |   10 
 vcl/source/edit/texteng.cxx                                |    4 
 vcl/source/edit/textview.cxx                               |    2 
 vcl/source/filter/FilterConfigCache.cxx                    |    6 
 vcl/source/filter/FilterConfigItem.cxx                     |    6 
 vcl/source/filter/GraphicNativeTransform.cxx               |    6 
 vcl/source/filter/bmp/BmpWriter.cxx                        |    4 
 vcl/source/filter/egif/egif.cxx                            |    2 
 vcl/source/filter/eps/eps.cxx                              |   10 
 vcl/source/filter/graphicfilter.cxx                        |   22 
 vcl/source/filter/ieps/ieps.cxx                            |   38 -
 vcl/source/filter/imet/ios2met.cxx                         |    4 
 vcl/source/filter/ipcd/ipcd.cxx                            |    2 
 vcl/source/filter/jpeg/JpegWriter.cxx                      |    6 
 vcl/source/filter/webp/writer.cxx                          |    6 
 vcl/source/filter/wmf/wmfwr.cxx                            |    2 
 vcl/source/font/PhysicalFontCollection.cxx                 |    4 
 vcl/source/gdi/FileDefinitionWidgetDraw.cxx                |    8 
 vcl/source/gdi/embeddedfontshelper.cxx                     |    8 
 vcl/source/gdi/formpdfexport.cxx                           |   38 -
 vcl/source/gdi/gdimtf.cxx                                  |    2 
 vcl/source/gdi/mtfxmldump.cxx                              |  252 +++----
 vcl/source/gdi/oldprintadaptor.cxx                         |    2 
 vcl/source/gdi/pdfwriter_impl.cxx                          |   10 
 vcl/source/gdi/pdfwriter_impl2.cxx                         |   14 
 vcl/source/gdi/print3.cxx                                  |  106 +--
 vcl/source/gdi/vectorgraphicdata.cxx                       |    4 
 vcl/source/gdi/virdev.cxx                                  |    2 
 vcl/source/graphic/GraphicObject.cxx                       |    8 
 vcl/source/graphic/UnoGraphic.cxx                          |    4 
 vcl/source/graphic/UnoGraphicDescriptor.cxx                |   24 
 vcl/source/graphic/UnoGraphicMapper.cxx                    |    4 
 vcl/source/graphic/UnoGraphicObject.cxx                    |    4 
 vcl/source/graphic/UnoGraphicProvider.cxx                  |    4 
 vcl/source/helper/canvasbitmap.cxx                         |    4 
 vcl/source/helper/commandinfoprovider.cxx                  |   20 
 vcl/source/helper/driverblocklist.cxx                      |   22 
 vcl/source/image/Image.cxx                                 |    2 
 vcl/source/image/ImplImageTree.cxx                         |    2 
 vcl/source/opengl/OpenGLHelper.cxx                         |   14 
 vcl/source/outdev/font.cxx                                 |    2 
 vcl/source/outdev/outdev.cxx                               |    4 
 vcl/source/outdev/text.cxx                                 |    4 
 vcl/source/pdf/PDFiumTools.cxx                             |    2 
 vcl/source/printer/Options.cxx                             |   33 
 vcl/source/treelist/iconview.cxx                           |    2 
 vcl/source/treelist/imap.cxx                               |    2 
 vcl/source/treelist/imap2.cxx                              |    4 
 vcl/source/treelist/transfer.cxx                           |    4 
 vcl/source/treelist/transfer2.cxx                          |    4 
 vcl/source/treelist/treelistbox.cxx                        |    2 
 vcl/source/treelist/uiobject.cxx                           |   28 
 vcl/source/uitest/logger.cxx                               |    6 
 vcl/source/uitest/uiobject.cxx                             |  254 +++----
 vcl/source/uitest/uitest.cxx                               |    6 
 vcl/source/uitest/uno/uiobject_uno.cxx                     |    4 
 vcl/source/uitest/uno/uitest_uno.cxx                       |    8 
 vcl/source/window/EnumContext.cxx                          |  104 +--
 vcl/source/window/builder.cxx                              |  126 +--
 vcl/source/window/cursor.cxx                               |    8 
 vcl/source/window/dialog.cxx                               |   20 
 vcl/source/window/dockwin.cxx                              |   10 
 vcl/source/window/floatwin.cxx                             |    6 
 vcl/source/window/keycod.cxx                               |    2 
 vcl/source/window/layout.cxx                               |   14 
 vcl/source/window/menu.cxx                                 |    2 
 vcl/source/window/paint.cxx                                |    2 
 vcl/source/window/printdlg.cxx                             |  194 ++---
 vcl/source/window/status.cxx                               |    4 
 vcl/source/window/toolbox2.cxx                             |    4 
 vcl/source/window/window.cxx                               |    8 
 vcl/unx/generic/app/geninst.cxx                            |    2 
 vcl/unx/generic/app/gensys.cxx                             |    6 
 vcl/unx/generic/app/i18n_im.cxx                            |    2 
 vcl/unx/generic/app/saldata.cxx                            |    2 
 vcl/unx/generic/app/salinst.cxx                            |    2 
 vcl/unx/generic/app/wmadaptor.cxx                          |    4 
 vcl/unx/generic/desktopdetect/desktopdetector.cxx          |    2 
 vcl/unx/generic/dtrans/X11_clipboard.cxx                   |    6 
 vcl/unx/generic/dtrans/X11_droptarget.cxx                  |    2 
 vcl/unx/generic/dtrans/X11_selection.cxx                   |   46 -
 vcl/unx/generic/dtrans/X11_service.cxx                     |    8 
 vcl/unx/generic/dtrans/X11_transferable.cxx                |    4 
 vcl/unx/generic/fontmanager/fontconfig.cxx                 |    4 
 vcl/unx/generic/fontmanager/helper.cxx                     |    6 
 vcl/unx/generic/gdi/X11CairoSalGraphicsImpl.hxx            |    2 
 vcl/unx/generic/print/genprnpsp.cxx                        |   36 -
 vcl/unx/generic/print/prtsetup.cxx                         |   60 -
 vcl/unx/generic/printer/cpdmgr.cxx                         |   18 
 vcl/unx/generic/printer/cupsmgr.cxx                        |   20 
 vcl/unx/generic/printer/jobdata.cxx                        |    4 
 vcl/unx/generic/printer/ppdparser.cxx                      |   38 -
 vcl/unx/generic/printer/printerinfomanager.cxx             |   10 
 vcl/unx/gtk3/fpicker/SalGtkFilePicker.cxx                  |    6 
 vcl/unx/gtk3/fpicker/SalGtkFolderPicker.cxx                |    2 
 vcl/unx/gtk3/fpicker/SalGtkPicker.cxx                      |    2 
 vcl/unx/gtk3/gtkinst.cxx                                   |   50 -
 vcl/unx/kf5/KFFilePicker.cxx                               |   10 
 vcl/workben/fftester.cxx                                   |   10 
 vcl/workben/icontest.cxx                                   |    2 
 vcl/workben/listfonts.cxx                                  |  170 ++---
 vcl/workben/listglyphs.cxx                                 |    2 
 vcl/workben/mtfdemo.cxx                                    |   10 
 vcl/workben/svdem.cxx                                      |    4 
 vcl/workben/svpclient.cxx                                  |    8 
 vcl/workben/svptest.cxx                                    |    6 
 vcl/workben/vcldemo.cxx                                    |   36 -
 194 files changed, 2237 insertions(+), 2224 deletions(-)

New commits:
commit 40dde4385cd913ac08292ad3be28bf17de9d296c
Author:     Noel Grandin <noel.gran...@collabora.co.uk>
AuthorDate: Fri May 10 13:19:35 2024 +0200
Commit:     Noel Grandin <noel.gran...@collabora.co.uk>
CommitDate: Fri May 10 18:44:00 2024 +0200

    loplugin:ostr in vcl
    
    Change-Id: I5b6ee5bda0c5ff69d297f7f8e87d4c3f3d21791c
    Reviewed-on: https://gerrit.libreoffice.org/c/core/+/167470
    Reviewed-by: Noel Grandin <noel.gran...@collabora.co.uk>
    Tested-by: Jenkins

diff --git a/include/vcl/textfilter.hxx b/include/vcl/textfilter.hxx
index 0113b28bcedc..bab09107e835 100644
--- a/include/vcl/textfilter.hxx
+++ b/include/vcl/textfilter.hxx
@@ -22,7 +22,7 @@ public:
 
     virtual OUString filter(const OUString& rText);
 
-    TextFilter(OUString aForbiddenChars = OUString(" "));
+    TextFilter(OUString aForbiddenChars = u" "_ustr);
     virtual ~TextFilter();
 };
 
diff --git a/include/vcl/weldutils.hxx b/include/vcl/weldutils.hxx
index 222e96a63158..3807c83c478a 100644
--- a/include/vcl/weldutils.hxx
+++ b/include/vcl/weldutils.hxx
@@ -68,12 +68,12 @@ public:
     // css::awt::XWindow
     void SAL_CALL setPosSize(sal_Int32, sal_Int32, sal_Int32, sal_Int32, 
sal_Int16) override
     {
-        throw css::uno::RuntimeException("not implemented");
+        throw css::uno::RuntimeException(u"not implemented"_ustr);
     }
 
     css::awt::Rectangle SAL_CALL getPosSize() override
     {
-        throw css::uno::RuntimeException("not implemented");
+        throw css::uno::RuntimeException(u"not implemented"_ustr);
     }
 
     void SAL_CALL setVisible(sal_Bool bVisible) override { 
m_pWeldWidget->set_visible(bVisible); }
diff --git a/vcl/backendtest/GraphicsRenderTests.cxx 
b/vcl/backendtest/GraphicsRenderTests.cxx
index 575a863e04e4..6f384d498ce8 100644
--- a/vcl/backendtest/GraphicsRenderTests.cxx
+++ b/vcl/backendtest/GraphicsRenderTests.cxx
@@ -84,7 +84,7 @@ public:
     {
         
vcl::test::setActiveGraphicsRenderTest(OUString::Concat("GraphicsRenderTest__") 
+ name);
     }
-    ~GraphicsTestZone() { vcl::test::setActiveGraphicsRenderTest(""); }
+    ~GraphicsTestZone() { vcl::test::setActiveGraphicsRenderTest(u""_ustr); }
 };
 }
 
@@ -93,25 +93,25 @@ OUString 
GraphicsRenderTests::returnTestStatus(vcl::test::TestResult const resul
     switch (result)
     {
         case vcl::test::TestResult::Passed:
-            return "PASSED";
+            return u"PASSED"_ustr;
         case vcl::test::TestResult::PassedWithQuirks:
-            return "QUIRKY";
+            return u"QUIRKY"_ustr;
         case vcl::test::TestResult::Failed:
-            return "FAILED";
+            return u"FAILED"_ustr;
     }
-    return "SKIPPED";
+    return u"SKIPPED"_ustr;
 }
 
 void GraphicsRenderTests::testDrawRectWithRectangle()
 {
-    OUString aTestName = "testDrawRectWithRectangle";
+    OUString aTestName = u"testDrawRectWithRectangle"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestRect aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(false);
     m_aCurGraphicsBackend = aOutDevTest.getRenderBackendName();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
@@ -126,13 +126,13 @@ void GraphicsRenderTests::testDrawRectWithRectangle()
 
 void GraphicsRenderTests::testDrawRectWithPixel()
 {
-    OUString aTestName = "testDrawRectWithPixel";
+    OUString aTestName = u"testDrawRectWithPixel"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPixel aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(false);
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
@@ -147,13 +147,13 @@ void GraphicsRenderTests::testDrawRectWithPixel()
 
 void GraphicsRenderTests::testDrawRectWithLine()
 {
-    OUString aTestName = "testDrawRectWithLine";
+    OUString aTestName = u"testDrawRectWithLine"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(false);
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
@@ -168,13 +168,13 @@ void GraphicsRenderTests::testDrawRectWithLine()
 
 void GraphicsRenderTests::testDrawRectWithPolygon()
 {
-    OUString aTestName = "testDrawRectWithPolygon";
+    OUString aTestName = u"testDrawRectWithPolygon"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(false);
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
@@ -189,13 +189,13 @@ void GraphicsRenderTests::testDrawRectWithPolygon()
 
 void GraphicsRenderTests::testDrawRectWithPolyLine()
 {
-    OUString aTestName = "testDrawRectWithPolyLine";
+    OUString aTestName = u"testDrawRectWithPolyLine"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(false);
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
@@ -210,13 +210,13 @@ void GraphicsRenderTests::testDrawRectWithPolyLine()
 
 void GraphicsRenderTests::testDrawRectWithPolyLineB2D()
 {
-    OUString aTestName = "testDrawRectWithPolyLineB2D";
+    OUString aTestName = u"testDrawRectWithPolyLineB2D"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(false);
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
@@ -231,13 +231,13 @@ void GraphicsRenderTests::testDrawRectWithPolyLineB2D()
 
 void GraphicsRenderTests::testDrawRectWithPolyPolygon()
 {
-    OUString aTestName = "testDrawRectWithPolyPolygon";
+    OUString aTestName = u"testDrawRectWithPolyPolygon"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(false);
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
@@ -252,13 +252,13 @@ void GraphicsRenderTests::testDrawRectWithPolyPolygon()
 
 void GraphicsRenderTests::testDrawRectWithPolyPolygonB2D()
 {
-    OUString aTestName = "testDrawRectWithPolyPolygonB2D";
+    OUString aTestName = u"testDrawRectWithPolyPolygonB2D"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyPolygonB2D aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(false);
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
@@ -273,13 +273,13 @@ void GraphicsRenderTests::testDrawRectWithPolyPolygonB2D()
 
 void GraphicsRenderTests::testDrawRectAAWithRectangle()
 {
-    OUString aTestName = "testDrawRectAAWithRectangle";
+    OUString aTestName = u"testDrawRectAAWithRectangle"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestRect aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(true);
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangleAA(aBitmap);
@@ -294,13 +294,13 @@ void GraphicsRenderTests::testDrawRectAAWithRectangle()
 
 void GraphicsRenderTests::testDrawRectAAWithPixel()
 {
-    OUString aTestName = "testDrawRectAAWithPixel";
+    OUString aTestName = u"testDrawRectAAWithPixel"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPixel aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(true);
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangleAA(aBitmap);
@@ -315,13 +315,13 @@ void GraphicsRenderTests::testDrawRectAAWithPixel()
 
 void GraphicsRenderTests::testDrawRectAAWithLine()
 {
-    OUString aTestName = "testDrawRectAAWithLine";
+    OUString aTestName = u"testDrawRectAAWithLine"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(true);
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangleAA(aBitmap);
@@ -336,13 +336,13 @@ void GraphicsRenderTests::testDrawRectAAWithLine()
 
 void GraphicsRenderTests::testDrawRectAAWithPolygon()
 {
-    OUString aTestName = "testDrawRectAAWithPolygon";
+    OUString aTestName = u"testDrawRectAAWithPolygon"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(true);
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangleAA(aBitmap);
@@ -357,13 +357,13 @@ void GraphicsRenderTests::testDrawRectAAWithPolygon()
 
 void GraphicsRenderTests::testDrawRectAAWithPolyLine()
 {
-    OUString aTestName = "testDrawRectAAWithPolyLine";
+    OUString aTestName = u"testDrawRectAAWithPolyLine"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(true);
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangleAA(aBitmap);
@@ -378,13 +378,13 @@ void GraphicsRenderTests::testDrawRectAAWithPolyLine()
 
 void GraphicsRenderTests::testDrawRectAAWithPolyLineB2D()
 {
-    OUString aTestName = "testDrawRectAAWithPolyLineB2D";
+    OUString aTestName = u"testDrawRectAAWithPolyLineB2D"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(true);
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangleAA(aBitmap);
@@ -399,13 +399,13 @@ void GraphicsRenderTests::testDrawRectAAWithPolyLineB2D()
 
 void GraphicsRenderTests::testDrawRectAAWithPolyPolygon()
 {
-    OUString aTestName = "testDrawRectAAWithPolyPolygon";
+    OUString aTestName = u"testDrawRectAAWithPolyPolygon"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(true);
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangleAA(aBitmap);
@@ -420,13 +420,13 @@ void GraphicsRenderTests::testDrawRectAAWithPolyPolygon()
 
 void GraphicsRenderTests::testDrawRectAAWithPolyPolygonB2D()
 {
-    OUString aTestName = "testDrawRectAAWithPolyPolygonB2D";
+    OUString aTestName = u"testDrawRectAAWithPolyPolygonB2D"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyPolygonB2D aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangle(true);
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangleAA(aBitmap);
@@ -441,13 +441,13 @@ void 
GraphicsRenderTests::testDrawRectAAWithPolyPolygonB2D()
 
 void GraphicsRenderTests::testDrawFilledRectWithRectangle()
 {
-    OUString aTestName = "testDrawFilledRectWithRectangle";
+    OUString aTestName = u"testDrawFilledRectWithRectangle"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestRect aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupFilledRectangle(false);
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -473,13 +473,13 @@ void 
GraphicsRenderTests::testDrawFilledRectWithRectangle()
 
 void GraphicsRenderTests::testDrawFilledRectWithPolygon()
 {
-    OUString aTestName = "testDrawFilledRectWithPolygon";
+    OUString aTestName = u"testDrawFilledRectWithPolygon"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupFilledRectangle(false);
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -505,13 +505,13 @@ void GraphicsRenderTests::testDrawFilledRectWithPolygon()
 
 void GraphicsRenderTests::testDrawFilledRectWithPolyPolygon()
 {
-    OUString aTestName = "testDrawFilledRectWithPolyPolygon";
+    OUString aTestName = u"testDrawFilledRectWithPolyPolygon"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupFilledRectangle(false);
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -537,13 +537,13 @@ void 
GraphicsRenderTests::testDrawFilledRectWithPolyPolygon()
 
 void GraphicsRenderTests::testDrawFilledRectWithPolyPolygon2D()
 {
-    OUString aTestName = "testDrawFilledRectWithPolyPolygon2D";
+    OUString aTestName = u"testDrawFilledRectWithPolyPolygon2D"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyPolygonB2D aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupFilledRectangle(false);
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -569,13 +569,13 @@ void 
GraphicsRenderTests::testDrawFilledRectWithPolyPolygon2D()
 
 void GraphicsRenderTests::testDrawDiamondWithPolygon()
 {
-    OUString aTestName = "testDrawDiamondWithPolygon";
+    OUString aTestName = u"testDrawDiamondWithPolygon"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupDiamond();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkDiamond(aBitmap);
@@ -590,13 +590,13 @@ void GraphicsRenderTests::testDrawDiamondWithPolygon()
 
 void GraphicsRenderTests::testDrawDiamondWithLine()
 {
-    OUString aTestName = "testDrawDiamondWithLine";
+    OUString aTestName = u"testDrawDiamondWithLine"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupDiamond();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkDiamond(aBitmap);
@@ -611,13 +611,13 @@ void GraphicsRenderTests::testDrawDiamondWithLine()
 
 void GraphicsRenderTests::testDrawDiamondWithPolyline()
 {
-    OUString aTestName = "testDrawDiamondWithPolyline";
+    OUString aTestName = u"testDrawDiamondWithPolyline"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupDiamond();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkDiamond(aBitmap);
@@ -632,13 +632,13 @@ void GraphicsRenderTests::testDrawDiamondWithPolyline()
 
 void GraphicsRenderTests::testDrawDiamondWithPolylineB2D()
 {
-    OUString aTestName = "testDrawDiamondWithPolylineB2D";
+    OUString aTestName = u"testDrawDiamondWithPolylineB2D"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupDiamond();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkDiamond(aBitmap);
@@ -653,13 +653,13 @@ void GraphicsRenderTests::testDrawDiamondWithPolylineB2D()
 
 void GraphicsRenderTests::testDrawInvertWithRectangle()
 {
-    OUString aTestName = "testDrawInvertWithRectangle";
+    OUString aTestName = u"testDrawInvertWithRectangle"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestRect aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupInvert_NONE();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -675,13 +675,13 @@ void GraphicsRenderTests::testDrawInvertWithRectangle()
 
 void GraphicsRenderTests::testDrawInvertN50WithRectangle()
 {
-    OUString aTestName = "testDrawInvertN50WithRectangle";
+    OUString aTestName = u"testDrawInvertN50WithRectangle"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestRect aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupInvert_N50();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -697,13 +697,13 @@ void GraphicsRenderTests::testDrawInvertN50WithRectangle()
 
 void GraphicsRenderTests::testDrawInvertTrackFrameWithRectangle()
 {
-    OUString aTestName = "testDrawInvertTrackFrameWithRectangle";
+    OUString aTestName = u"testDrawInvertTrackFrameWithRectangle"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestRect aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupInvert_TrackFrame();
     if (!(SHOULD_ASSERT && aOutDevTest.getRenderBackendName() != "svp"))
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -719,13 +719,13 @@ void 
GraphicsRenderTests::testDrawInvertTrackFrameWithRectangle()
 
 void GraphicsRenderTests::testDrawDropShapeWithPolyline()
 {
-    OUString aTestName = "testDrawDropShapeWithPolyline";
+    OUString aTestName = u"testDrawDropShapeWithPolyline"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupDropShape();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkDropShape(aBitmap);
@@ -740,13 +740,13 @@ void GraphicsRenderTests::testDrawDropShapeWithPolyline()
 
 void GraphicsRenderTests::testDrawDropShapeAAWithPolyline()
 {
-    OUString aTestName = "testDrawDropShapeAAWithPolyline";
+    OUString aTestName = u"testDrawDropShapeAAWithPolyline"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupAADropShape();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -762,13 +762,13 @@ void 
GraphicsRenderTests::testDrawDropShapeAAWithPolyline()
 
 void GraphicsRenderTests::testDrawBezierWithPolylineB2D()
 {
-    OUString aTestName = "testDrawBezierWithPolylineB2D";
+    OUString aTestName = u"testDrawBezierWithPolylineB2D"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupBezier();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkBezier(aBitmap);
@@ -783,13 +783,13 @@ void GraphicsRenderTests::testDrawBezierWithPolylineB2D()
 
 void GraphicsRenderTests::testDrawBezierAAWithPolylineB2D()
 {
-    OUString aTestName = "testDrawBezierAAWithPolylineB2D";
+    OUString aTestName = u"testDrawBezierAAWithPolylineB2D"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupAABezier();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkBezier(aBitmap);
@@ -804,13 +804,13 @@ void 
GraphicsRenderTests::testDrawBezierAAWithPolylineB2D()
 
 void GraphicsRenderTests::testDrawDropShapeWithPolygon()
 {
-    OUString aTestName = "testDrawDropShapeWithPolygon";
+    OUString aTestName = u"testDrawDropShapeWithPolygon"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupDropShape();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkDropShape(aBitmap);
@@ -825,13 +825,13 @@ void GraphicsRenderTests::testDrawDropShapeWithPolygon()
 
 void GraphicsRenderTests::testDrawDropShapeAAWithPolygon()
 {
-    OUString aTestName = "testDrawDropShapeAAWithPolygon";
+    OUString aTestName = u"testDrawDropShapeAAWithPolygon"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupAADropShape();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -847,13 +847,13 @@ void GraphicsRenderTests::testDrawDropShapeAAWithPolygon()
 
 void GraphicsRenderTests::testDrawBitmap24bpp()
 {
-    OUString aTestName = "testDrawBitmap24bpp";
+    OUString aTestName = u"testDrawBitmap24bpp"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestBitmap aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupDrawBitmap(vcl::PixelFormat::N24_BPP);
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -869,13 +869,13 @@ void GraphicsRenderTests::testDrawBitmap24bpp()
 
 void GraphicsRenderTests::testDrawTransformedBitmap24bpp()
 {
-    OUString aTestName = "testDrawTransformedBitmap24bpp";
+    OUString aTestName = u"testDrawTransformedBitmap24bpp"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestBitmap aOutDevTest;
     Bitmap aBitmap = 
aOutDevTest.setupDrawTransformedBitmap(vcl::PixelFormat::N24_BPP);
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -891,13 +891,13 @@ void GraphicsRenderTests::testDrawTransformedBitmap24bpp()
 
 void GraphicsRenderTests::testComplexDrawTransformedBitmap24bpp()
 {
-    OUString aTestName = "testComplexDrawTransformedBitmap24bpp";
+    OUString aTestName = u"testComplexDrawTransformedBitmap24bpp"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestBitmap aOutDevTest;
     Bitmap aBitmap = 
aOutDevTest.setupComplexDrawTransformedBitmap(vcl::PixelFormat::N24_BPP);
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -913,13 +913,13 @@ void 
GraphicsRenderTests::testComplexDrawTransformedBitmap24bpp()
 
 void GraphicsRenderTests::testDrawBitmapExWithAlpha24bpp()
 {
-    OUString aTestName = "testDrawBitmapExWithAlpha24bpp";
+    OUString aTestName = u"testDrawBitmapExWithAlpha24bpp"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestBitmap aOutDevTest;
     Bitmap aBitmap = 
aOutDevTest.setupDrawBitmapExWithAlpha(vcl::PixelFormat::N24_BPP);
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -935,13 +935,13 @@ void GraphicsRenderTests::testDrawBitmapExWithAlpha24bpp()
 
 void GraphicsRenderTests::testDrawMask24bpp()
 {
-    OUString aTestName = "testDrawMask24bpp";
+    OUString aTestName = u"testDrawMask24bpp"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestBitmap aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupDrawMask(vcl::PixelFormat::N24_BPP);
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestBitmap::checkMask(aBitmap);
@@ -956,13 +956,13 @@ void GraphicsRenderTests::testDrawMask24bpp()
 
 void GraphicsRenderTests::testDrawBlend24bpp()
 {
-    OUString aTestName = "testDrawBlend24bpp";
+    OUString aTestName = u"testDrawBlend24bpp"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestBitmap aOutDevTest;
     BitmapEx aBitmapEx = aOutDevTest.setupDrawBlend(vcl::PixelFormat::N24_BPP);
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestBitmap::checkBlend(aBitmapEx);
@@ -976,13 +976,13 @@ void GraphicsRenderTests::testDrawBlend24bpp()
 
 void GraphicsRenderTests::testDrawXor()
 {
-    OUString aTestName = "testDrawXor";
+    OUString aTestName = u"testDrawXor"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestAnotherOutDev aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupXOR();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestAnotherOutDev::checkXOR(aBitmap);
@@ -997,13 +997,13 @@ void GraphicsRenderTests::testDrawXor()
 
 void GraphicsRenderTests::testClipRectangle()
 {
-    OUString aTestName = "testClipRectangle";
+    OUString aTestName = u"testClipRectangle"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestClip aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupClipRectangle();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestClip::checkClip(aBitmap);
@@ -1018,13 +1018,13 @@ void GraphicsRenderTests::testClipRectangle()
 
 void GraphicsRenderTests::testClipPolygon()
 {
-    OUString aTestName = "testClipPolygon";
+    OUString aTestName = u"testClipPolygon"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestClip aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupClipPolygon();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestClip::checkClip(aBitmap);
@@ -1039,13 +1039,13 @@ void GraphicsRenderTests::testClipPolygon()
 
 void GraphicsRenderTests::testClipPolyPolygon()
 {
-    OUString aTestName = "testClipPolyPolygon";
+    OUString aTestName = u"testClipPolyPolygon"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestClip aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupClipPolyPolygon();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestClip::checkClip(aBitmap);
@@ -1060,13 +1060,13 @@ void GraphicsRenderTests::testClipPolyPolygon()
 
 void GraphicsRenderTests::testClipB2DPolyPolygon()
 {
-    OUString aTestName = "testClipB2DPolyPolygon";
+    OUString aTestName = u"testClipB2DPolyPolygon"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestClip aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupClipB2DPolyPolygon();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestClip::checkClip(aBitmap);
@@ -1081,13 +1081,13 @@ void GraphicsRenderTests::testClipB2DPolyPolygon()
 
 void GraphicsRenderTests::testDrawOutDev()
 {
-    OUString aTestName = "testDrawOutDev";
+    OUString aTestName = u"testDrawOutDev"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestAnotherOutDev aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupDrawOutDev();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -1103,13 +1103,13 @@ void GraphicsRenderTests::testDrawOutDev()
 
 void GraphicsRenderTests::testDrawOutDevScaledClipped()
 {
-    OUString aTestName = "testDrawOutDevScaledClipped";
+    OUString aTestName = u"testDrawOutDevScaledClipped"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestAnotherOutDev aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupDrawOutDevScaledClipped();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -1125,13 +1125,13 @@ void GraphicsRenderTests::testDrawOutDevScaledClipped()
 
 void GraphicsRenderTests::testDrawOutDevSelf()
 {
-    OUString aTestName = "testDrawOutDevSelf";
+    OUString aTestName = u"testDrawOutDevSelf"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestAnotherOutDev aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupDrawOutDevSelf();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -1147,13 +1147,13 @@ void GraphicsRenderTests::testDrawOutDevSelf()
 
 void GraphicsRenderTests::testDashedLine()
 {
-    OUString aTestName = "testDashedLine";
+    OUString aTestName = u"testDashedLine"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupDashedLine();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestLine::checkDashedLine(aBitmap);
@@ -1168,13 +1168,13 @@ void GraphicsRenderTests::testDashedLine()
 
 void GraphicsRenderTests::testLinearGradient()
 {
-    OUString aTestName = "testLinearGradient";
+    OUString aTestName = u"testLinearGradient"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestGradient aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupLinearGradient();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -1190,13 +1190,13 @@ void GraphicsRenderTests::testLinearGradient()
 
 void GraphicsRenderTests::testLinearGradientAngled()
 {
-    OUString aTestName = "testLinearGradientAngled";
+    OUString aTestName = u"testLinearGradientAngled"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestGradient aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupLinearGradientAngled();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -1212,13 +1212,13 @@ void GraphicsRenderTests::testLinearGradientAngled()
 
 void GraphicsRenderTests::testLinearGradientBorder()
 {
-    OUString aTestName = "testLinearGradientBorder";
+    OUString aTestName = u"testLinearGradientBorder"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestGradient aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupLinearGradientBorder();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -1234,13 +1234,13 @@ void GraphicsRenderTests::testLinearGradientBorder()
 
 void GraphicsRenderTests::testLinearGradientIntensity()
 {
-    OUString aTestName = "testLinearGradientIntensity";
+    OUString aTestName = u"testLinearGradientIntensity"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestGradient aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupLinearGradientIntensity();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -1256,13 +1256,13 @@ void GraphicsRenderTests::testLinearGradientIntensity()
 
 void GraphicsRenderTests::testLinearGradientSteps()
 {
-    OUString aTestName = "testLinearGradientSteps";
+    OUString aTestName = u"testLinearGradientSteps"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestGradient aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupLinearGradientSteps();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -1278,13 +1278,13 @@ void GraphicsRenderTests::testLinearGradientSteps()
 
 void GraphicsRenderTests::testAxialGradient()
 {
-    OUString aTestName = "testAxialGradient";
+    OUString aTestName = u"testAxialGradient"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestGradient aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupAxialGradient();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -1300,13 +1300,13 @@ void GraphicsRenderTests::testAxialGradient()
 
 void GraphicsRenderTests::testRadialGradient()
 {
-    OUString aTestName = "testRadialGradient";
+    OUString aTestName = u"testRadialGradient"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestGradient aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRadialGradient();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -1322,13 +1322,13 @@ void GraphicsRenderTests::testRadialGradient()
 
 void GraphicsRenderTests::testRadialGradientOfs()
 {
-    OUString aTestName = "testRadialGradientOfs";
+    OUString aTestName = u"testRadialGradientOfs"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestGradient aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRadialGradientOfs();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -1339,13 +1339,13 @@ void GraphicsRenderTests::testRadialGradientOfs()
 
 void GraphicsRenderTests::testLineJoinBevel()
 {
-    OUString aTestName = "testLineJoinBevel";
+    OUString aTestName = u"testLineJoinBevel"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupLineJoinBevel();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestLine::checkLineJoinBevel(aBitmap);
@@ -1360,13 +1360,13 @@ void GraphicsRenderTests::testLineJoinBevel()
 
 void GraphicsRenderTests::testLineJoinRound()
 {
-    OUString aTestName = "testLineJoinRound";
+    OUString aTestName = u"testLineJoinRound"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupLineJoinRound();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestLine::checkLineJoinRound(aBitmap);
@@ -1381,13 +1381,13 @@ void GraphicsRenderTests::testLineJoinRound()
 
 void GraphicsRenderTests::testLineJoinMiter()
 {
-    OUString aTestName = "testLineJoinMiter";
+    OUString aTestName = u"testLineJoinMiter"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupLineJoinMiter();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestLine::checkLineJoinMiter(aBitmap);
@@ -1402,13 +1402,13 @@ void GraphicsRenderTests::testLineJoinMiter()
 
 void GraphicsRenderTests::testLineJoinNone()
 {
-    OUString aTestName = "testLineJoinNone";
+    OUString aTestName = u"testLineJoinNone"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupLineJoinNone();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestLine::checkLineJoinNone(aBitmap);
@@ -1423,13 +1423,13 @@ void GraphicsRenderTests::testLineJoinNone()
 
 void GraphicsRenderTests::testLineCapRound()
 {
-    OUString aTestName = "testLineCapRound";
+    OUString aTestName = u"testLineCapRound"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupLineCapRound();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestLine::checkLineCapRound(aBitmap);
@@ -1444,13 +1444,13 @@ void GraphicsRenderTests::testLineCapRound()
 
 void GraphicsRenderTests::testLineCapSquare()
 {
-    OUString aTestName = "testLineCapSquare";
+    OUString aTestName = u"testLineCapSquare"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupLineCapSquare();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestLine::checkLineCapSquare(aBitmap);
@@ -1465,13 +1465,13 @@ void GraphicsRenderTests::testLineCapSquare()
 
 void GraphicsRenderTests::testLineCapButt()
 {
-    OUString aTestName = "testLineCapButt";
+    OUString aTestName = u"testLineCapButt"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupLineCapButt();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestLine::checkLineCapButt(aBitmap);
@@ -1486,13 +1486,13 @@ void GraphicsRenderTests::testLineCapButt()
 
 void GraphicsRenderTests::testHalfEllipseWithPolyLine()
 {
-    OUString aTestName = "testHalfEllipseWithPolyLine";
+    OUString aTestName = u"testHalfEllipseWithPolyLine"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupHalfEllipse();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestLine::checkHalfEllipse(aBitmap);
@@ -1507,13 +1507,13 @@ void GraphicsRenderTests::testHalfEllipseWithPolyLine()
 
 void GraphicsRenderTests::testHalfEllipseAAWithPolyLine()
 {
-    OUString aTestName = "testHalfEllipseAAWithPolyLine";
+    OUString aTestName = u"testHalfEllipseAAWithPolyLine"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupHalfEllipse(true);
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -1529,13 +1529,13 @@ void 
GraphicsRenderTests::testHalfEllipseAAWithPolyLine()
 
 void GraphicsRenderTests::testHalfEllipseWithPolyLineB2D()
 {
-    OUString aTestName = "testHalfEllipseWithPolyLineB2D";
+    OUString aTestName = u"testHalfEllipseWithPolyLineB2D"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupHalfEllipse();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestLine::checkHalfEllipse(aBitmap);
@@ -1550,13 +1550,13 @@ void 
GraphicsRenderTests::testHalfEllipseWithPolyLineB2D()
 
 void GraphicsRenderTests::testHalfEllipseAAWithPolyLineB2D()
 {
-    OUString aTestName = "testHalfEllipseAAWithPolyLineB2D";
+    OUString aTestName = u"testHalfEllipseAAWithPolyLineB2D"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupHalfEllipse(true);
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -1572,13 +1572,13 @@ void 
GraphicsRenderTests::testHalfEllipseAAWithPolyLineB2D()
 
 void GraphicsRenderTests::testHalfEllipseWithPolygon()
 {
-    OUString aTestName = "testHalfEllipseWithPolygon";
+    OUString aTestName = u"testHalfEllipseWithPolygon"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupHalfEllipse();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestLine::checkHalfEllipse(aBitmap);
@@ -1593,13 +1593,13 @@ void GraphicsRenderTests::testHalfEllipseWithPolygon()
 
 void GraphicsRenderTests::testClosedBezierWithPolyline()
 {
-    OUString aTestName = "testClosedBezierWithPolyline";
+    OUString aTestName = u"testClosedBezierWithPolyline"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupClosedBezier();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkClosedBezier(aBitmap);
@@ -1614,13 +1614,13 @@ void GraphicsRenderTests::testClosedBezierWithPolyline()
 
 void GraphicsRenderTests::testClosedBezierWithPolygon()
 {
-    OUString aTestName = "testClosedBezierWithPolygon";
+    OUString aTestName = u"testClosedBezierWithPolygon"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupClosedBezier();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkClosedBezier(aBitmap);
@@ -1635,13 +1635,13 @@ void GraphicsRenderTests::testClosedBezierWithPolygon()
 
 void GraphicsRenderTests::testHalfEllipseAAWithPolygon()
 {
-    OUString aTestName = "testHalfEllipseAAWithPolygon";
+    OUString aTestName = u"testHalfEllipseAAWithPolygon"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupHalfEllipse(true);
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -1657,7 +1657,7 @@ void GraphicsRenderTests::testHalfEllipseAAWithPolygon()
 
 void GraphicsRenderTests::testFilledAsymmetricalDropShape()
 {
-    OUString aTestName = "testFilledAsymmetricalDropShape";
+    OUString aTestName = u"testFilledAsymmetricalDropShape"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupFilledAsymmetricalDropShape();
@@ -1674,13 +1674,13 @@ void 
GraphicsRenderTests::testFilledAsymmetricalDropShape()
 
 void GraphicsRenderTests::testTextDrawing()
 {
-    OUString aTestName = "testTextDrawing";
+    OUString aTestName = u"testTextDrawing"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestText aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupTextBitmap();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestLine::checkTextLocation(aBitmap);
@@ -1695,13 +1695,13 @@ void GraphicsRenderTests::testTextDrawing()
 
 void GraphicsRenderTests::testEvenOddRuleInIntersectingRectsWithPolyPolygon()
 {
-    OUString aTestName = "testEvenOddRuleInIntersectingRectsWithPolyPolygon";
+    OUString aTestName = 
u"testEvenOddRuleInIntersectingRectsWithPolyPolygon"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupIntersectingRectangles();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -1717,13 +1717,13 @@ void 
GraphicsRenderTests::testEvenOddRuleInIntersectingRectsWithPolyPolygon()
 
 void 
GraphicsRenderTests::testEvenOddRuleInIntersectingRectsWithPolyPolygonB2D()
 {
-    OUString aTestName = 
"testEvenOddRuleInIntersectingRectsWithPolyPolygonB2D";
+    OUString aTestName = 
u"testEvenOddRuleInIntersectingRectsWithPolyPolygonB2D"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyPolygonB2D aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupIntersectingRectangles();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -1739,13 +1739,13 @@ void 
GraphicsRenderTests::testEvenOddRuleInIntersectingRectsWithPolyPolygonB2D()
 
 void GraphicsRenderTests::testDrawBitmap8bppGreyScale()
 {
-    OUString aTestName = "testDrawBitmap8bppGreyScale";
+    OUString aTestName = u"testDrawBitmap8bppGreyScale"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestBitmap aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupDrawBitmap(vcl::PixelFormat::N8_BPP, 
true);
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -1761,13 +1761,13 @@ void GraphicsRenderTests::testDrawBitmap8bppGreyScale()
 
 void GraphicsRenderTests::testDrawTransformedBitmap8bppGreyScale()
 {
-    OUString aTestName = "testDrawTransformedBitmap8bppGreyScale";
+    OUString aTestName = u"testDrawTransformedBitmap8bppGreyScale"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestBitmap aOutDevTest;
     Bitmap aBitmap = 
aOutDevTest.setupDrawTransformedBitmap(vcl::PixelFormat::N8_BPP, true);
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -1783,13 +1783,13 @@ void 
GraphicsRenderTests::testDrawTransformedBitmap8bppGreyScale()
 
 void GraphicsRenderTests::testDrawBitmap32bpp()
 {
-    OUString aTestName = "testDrawBitmap32bpp";
+    OUString aTestName = u"testDrawBitmap32bpp"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestBitmap aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupDrawBitmap(vcl::PixelFormat::N32_BPP);
     if (!SHOULD_ASSERT || !is32bppSupported())
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -1805,13 +1805,13 @@ void GraphicsRenderTests::testDrawBitmap32bpp()
 
 void GraphicsRenderTests::testDrawTransformedBitmap32bpp()
 {
-    OUString aTestName = "testDrawTransformedBitmap32bpp";
+    OUString aTestName = u"testDrawTransformedBitmap32bpp"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestBitmap aOutDevTest;
     Bitmap aBitmap = 
aOutDevTest.setupDrawTransformedBitmap(vcl::PixelFormat::N32_BPP);
     if (!SHOULD_ASSERT || !is32bppSupported())
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -1827,13 +1827,13 @@ void 
GraphicsRenderTests::testDrawTransformedBitmap32bpp()
 
 void GraphicsRenderTests::testDrawBitmapExWithAlpha32bpp()
 {
-    OUString aTestName = "testDrawBitmapExWithAlpha32bpp";
+    OUString aTestName = u"testDrawBitmapExWithAlpha32bpp"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestBitmap aOutDevTest;
     Bitmap aBitmap = 
aOutDevTest.setupDrawBitmapExWithAlpha(vcl::PixelFormat::N32_BPP);
     if (!SHOULD_ASSERT || !is32bppSupported())
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult
@@ -1849,13 +1849,13 @@ void 
GraphicsRenderTests::testDrawBitmapExWithAlpha32bpp()
 
 void GraphicsRenderTests::testDrawMask32bpp()
 {
-    OUString aTestName = "testDrawMask32bpp";
+    OUString aTestName = u"testDrawMask32bpp"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestBitmap aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupDrawMask(vcl::PixelFormat::N32_BPP);
     if (!SHOULD_ASSERT || !is32bppSupported())
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestBitmap::checkMask(aBitmap);
@@ -1870,13 +1870,13 @@ void GraphicsRenderTests::testDrawMask32bpp()
 
 void GraphicsRenderTests::testDrawBlend32bpp()
 {
-    OUString aTestName = "testDrawBlend32bpp";
+    OUString aTestName = u"testDrawBlend32bpp"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestBitmap aOutDevTest;
     BitmapEx aBitmapEx = aOutDevTest.setupDrawBlend(vcl::PixelFormat::N32_BPP);
     if (!SHOULD_ASSERT || !is32bppSupported())
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestBitmap::checkBlend(aBitmapEx);
@@ -1890,14 +1890,14 @@ void GraphicsRenderTests::testDrawBlend32bpp()
 
 void GraphicsRenderTests::testDrawRectangleOnSize1028WithRect()
 {
-    OUString aTestName = "testDrawRectangleOnSize1028WithRect";
+    OUString aTestName = u"testDrawRectangleOnSize1028WithRect"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestRect aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangleOnSize1028();
     m_aCurGraphicsBackend = aOutDevTest.getRenderBackendName();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
@@ -1912,14 +1912,14 @@ void 
GraphicsRenderTests::testDrawRectangleOnSize1028WithRect()
 
 void GraphicsRenderTests::testDrawRectangleOnSize4096WithRect()
 {
-    OUString aTestName = "testDrawRectangleOnSize4096WithRect";
+    OUString aTestName = u"testDrawRectangleOnSize4096WithRect"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestRect aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangleOnSize4096();
     m_aCurGraphicsBackend = aOutDevTest.getRenderBackendName();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
@@ -1934,13 +1934,13 @@ void 
GraphicsRenderTests::testDrawRectangleOnSize4096WithRect()
 
 void GraphicsRenderTests::testDrawRectangleOnSize1028WithPixel()
 {
-    OUString aTestName = "testDrawRectangleOnSize1028WithPixel";
+    OUString aTestName = u"testDrawRectangleOnSize1028WithPixel"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPixel aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangleOnSize1028();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
@@ -1955,13 +1955,13 @@ void 
GraphicsRenderTests::testDrawRectangleOnSize1028WithPixel()
 
 void GraphicsRenderTests::testDrawRectangleOnSize4096WithPixel()
 {
-    OUString aTestName = "testDrawRectangleOnSize4096WithPixel";
+    OUString aTestName = u"testDrawRectangleOnSize4096WithPixel"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPixel aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangleOnSize4096();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
@@ -1976,13 +1976,13 @@ void 
GraphicsRenderTests::testDrawRectangleOnSize4096WithPixel()
 
 void GraphicsRenderTests::testDrawRectangleOnSize1028WithLine()
 {
-    OUString aTestName = "testDrawRectangleOnSize1028WithLine";
+    OUString aTestName = u"testDrawRectangleOnSize1028WithLine"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangleOnSize1028();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
@@ -1997,13 +1997,13 @@ void 
GraphicsRenderTests::testDrawRectangleOnSize1028WithLine()
 
 void GraphicsRenderTests::testDrawRectangleOnSize4096WithLine()
 {
-    OUString aTestName = "testDrawRectangleOnSize4096WithLine";
+    OUString aTestName = u"testDrawRectangleOnSize4096WithLine"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangleOnSize4096();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
@@ -2018,13 +2018,13 @@ void 
GraphicsRenderTests::testDrawRectangleOnSize4096WithLine()
 
 void GraphicsRenderTests::testDrawRectangleOnSize1028WithPolyLine()
 {
-    OUString aTestName = "testDrawRectangleOnSize1028WithPolyLine";
+    OUString aTestName = u"testDrawRectangleOnSize1028WithPolyLine"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangleOnSize1028();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
@@ -2039,13 +2039,13 @@ void 
GraphicsRenderTests::testDrawRectangleOnSize1028WithPolyLine()
 
 void GraphicsRenderTests::testDrawRectangleOnSize4096WithPolyLine()
 {
-    OUString aTestName = "testDrawRectangleOnSize4096WithPolyLine";
+    OUString aTestName = u"testDrawRectangleOnSize4096WithPolyLine"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangleOnSize4096();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
@@ -2060,13 +2060,13 @@ void 
GraphicsRenderTests::testDrawRectangleOnSize4096WithPolyLine()
 
 void GraphicsRenderTests::testDrawRectangleOnSize1028WithPolygon()
 {
-    OUString aTestName = "testDrawRectangleOnSize1028WithPolygon";
+    OUString aTestName = u"testDrawRectangleOnSize1028WithPolygon"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangleOnSize1028();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
@@ -2081,13 +2081,13 @@ void 
GraphicsRenderTests::testDrawRectangleOnSize1028WithPolygon()
 
 void GraphicsRenderTests::testDrawRectangleOnSize4096WithPolygon()
 {
-    OUString aTestName = "testDrawRectangleOnSize4096WithPolygon";
+    OUString aTestName = u"testDrawRectangleOnSize4096WithPolygon"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangleOnSize4096();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
@@ -2102,13 +2102,13 @@ void 
GraphicsRenderTests::testDrawRectangleOnSize4096WithPolygon()
 
 void GraphicsRenderTests::testDrawRectangleOnSize1028WithPolyLineB2D()
 {
-    OUString aTestName = "testDrawRectangleOnSize1028WithPolyLineB2D";
+    OUString aTestName = u"testDrawRectangleOnSize1028WithPolyLineB2D"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangleOnSize1028();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
@@ -2123,13 +2123,13 @@ void 
GraphicsRenderTests::testDrawRectangleOnSize1028WithPolyLineB2D()
 
 void GraphicsRenderTests::testDrawRectangleOnSize4096WithPolyLineB2D()
 {
-    OUString aTestName = "testDrawRectangleOnSize4096WithPolyLineB2D";
+    OUString aTestName = u"testDrawRectangleOnSize4096WithPolyLineB2D"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangleOnSize4096();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
@@ -2144,13 +2144,13 @@ void 
GraphicsRenderTests::testDrawRectangleOnSize4096WithPolyLineB2D()
 
 void GraphicsRenderTests::testDrawRectangleOnSize1028WithPolyPolygon()
 {
-    OUString aTestName = "testDrawRectangleOnSize1028WithPolyPolygon";
+    OUString aTestName = u"testDrawRectangleOnSize1028WithPolyPolygon"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangleOnSize1028();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
@@ -2165,13 +2165,13 @@ void 
GraphicsRenderTests::testDrawRectangleOnSize1028WithPolyPolygon()
 
 void GraphicsRenderTests::testDrawRectangleOnSize4096WithPolyPolygon()
 {
-    OUString aTestName = "testDrawRectangleOnSize4096WithPolyPolygon";
+    OUString aTestName = u"testDrawRectangleOnSize4096WithPolyPolygon"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangleOnSize4096();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
@@ -2186,13 +2186,13 @@ void 
GraphicsRenderTests::testDrawRectangleOnSize4096WithPolyPolygon()
 
 void GraphicsRenderTests::testDrawRectangleOnSize1028WithPolyPolygonB2D()
 {
-    OUString aTestName = "testDrawRectangleOnSize1028WithPolyPolygonB2D";
+    OUString aTestName = u"testDrawRectangleOnSize1028WithPolyPolygonB2D"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyPolygonB2D aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangleOnSize1028();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
@@ -2207,13 +2207,13 @@ void 
GraphicsRenderTests::testDrawRectangleOnSize1028WithPolyPolygonB2D()
 
 void GraphicsRenderTests::testDrawRectangleOnSize4096WithPolygonPolygonB2D()
 {
-    OUString aTestName = "testDrawRectangleOnSize4096WithPolygonPolygonB2D";
+    OUString aTestName = 
u"testDrawRectangleOnSize4096WithPolygonPolygonB2D"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyPolygonB2D aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupRectangleOnSize4096();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
@@ -2228,13 +2228,13 @@ void 
GraphicsRenderTests::testDrawRectangleOnSize4096WithPolygonPolygonB2D()
 
 void GraphicsRenderTests::testDrawOpenPolygonWithPolyLine()
 {
-    OUString aTestName = "testDrawOpenPolygonWithPolyLine";
+    OUString aTestName = u"testDrawOpenPolygonWithPolyLine"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupOpenPolygon();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkOpenPolygon(aBitmap);
@@ -2249,13 +2249,13 @@ void 
GraphicsRenderTests::testDrawOpenPolygonWithPolyLine()
 
 void GraphicsRenderTests::testDrawOpenPolygonWithPolyLineB2D()
 {
-    OUString aTestName = "testDrawOpenPolygonWithPolyLineB2D";
+    OUString aTestName = u"testDrawOpenPolygonWithPolyLineB2D"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupOpenPolygon();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkOpenPolygon(aBitmap);
@@ -2270,13 +2270,13 @@ void 
GraphicsRenderTests::testDrawOpenPolygonWithPolyLineB2D()
 
 void GraphicsRenderTests::testDrawOpenPolygonWithPolygon()
 {
-    OUString aTestName = "testDrawOpenPolygonWithPolygon";
+    OUString aTestName = u"testDrawOpenPolygonWithPolygon"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupOpenPolygon();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkOpenPolygon(aBitmap);
@@ -2291,13 +2291,13 @@ void 
GraphicsRenderTests::testDrawOpenPolygonWithPolygon()
 
 void GraphicsRenderTests::testDrawOpenPolygonWithPolyPolygon()
 {
-    OUString aTestName = "testDrawOpenPolygonWithPolyPolygon";
+    OUString aTestName = u"testDrawOpenPolygonWithPolyPolygon"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupOpenPolygon();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkOpenPolygon(aBitmap);
@@ -2312,13 +2312,13 @@ void 
GraphicsRenderTests::testDrawOpenPolygonWithPolyPolygon()
 
 void GraphicsRenderTests::testDrawOpenPolygonWithPolyPolygonB2D()
 {
-    OUString aTestName = "testDrawOpenPolygonWithPolyPolygonB2D";
+    OUString aTestName = u"testDrawOpenPolygonWithPolyPolygonB2D"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyPolygon aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupOpenPolygon();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkOpenPolygon(aBitmap);
@@ -2333,13 +2333,13 @@ void 
GraphicsRenderTests::testDrawOpenPolygonWithPolyPolygonB2D()
 
 void GraphicsRenderTests::testDrawOpenBezierWithPolyLine()
 {
-    OUString aTestName = "testDrawOpenBezierWithPolyLine";
+    OUString aTestName = u"testDrawOpenBezierWithPolyLine"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupOpenBezier();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkOpenBezier(aBitmap);
@@ -2354,13 +2354,13 @@ void 
GraphicsRenderTests::testDrawOpenBezierWithPolyLine()
 
 void GraphicsRenderTests::testDrawOpenBezierWithPolyLineB2D()
 {
-    OUString aTestName = "testDrawOpenBezierWithPolyLineB2D";
+    OUString aTestName = u"testDrawOpenBezierWithPolyLineB2D"_ustr;
     GraphicsTestZone zone(aTestName);
     vcl::test::OutputDeviceTestPolyLine aOutDevTest;
     Bitmap aBitmap = aOutDevTest.setupOpenBezier();
     if (!SHOULD_ASSERT)
     {
-        appendTestResult(aTestName, "SKIPPED");
+        appendTestResult(aTestName, u"SKIPPED"_ustr);
         return;
     }
     vcl::test::TestResult eResult = 
vcl::test::OutputDeviceTestCommon::checkOpenBezier(aBitmap);
@@ -2556,9 +2556,9 @@ void GraphicsRenderTests::run(bool storeResultBitmap)
         aTests[tests.getStatus()].push_back(tests.getTestName());
     }
     OUString writeResult = getResultString() + "
---Name of the tests that failed---
";
-    if (static_cast<int>(aTests["FAILED"].size()) > 0)
+    if (static_cast<int>(aTests[u"FAILED"_ustr].size()) > 0)
     {
-        for (const class OUString& tests : aTests["FAILED"])
+        for (const class OUString& tests : aTests[u"FAILED"_ustr])
         {
             writeResult += tests + "
";
         }
@@ -2568,9 +2568,9 @@ void GraphicsRenderTests::run(bool storeResultBitmap)
         writeResult += "No test has been failed.
";
     }
     writeResult += "
---Name of the tests that were Quirky---
";
-    if (static_cast<int>(aTests["QUIRKY"].size()) > 0)
+    if (static_cast<int>(aTests[u"QUIRKY"_ustr].size()) > 0)
     {
-        for (const class OUString& tests : aTests["QUIRKY"])
+        for (const class OUString& tests : aTests[u"QUIRKY"_ustr])
         {
             writeResult += tests + "
";
         }
@@ -2580,9 +2580,9 @@ void GraphicsRenderTests::run(bool storeResultBitmap)
         writeResult += "No test was Quirky.
";
     }
     writeResult += "
---Name of the tests that were Skipped---
";
-    if (static_cast<int>(aTests["SKIPPED"].size()) > 0)
+    if (static_cast<int>(aTests[u"SKIPPED"_ustr].size()) > 0)
     {
-        for (const class OUString& tests : aTests["SKIPPED"])
+        for (const class OUString& tests : aTests[u"SKIPPED"_ustr])
         {
             writeResult += tests + "
";
         }
diff --git a/vcl/backendtest/VisualBackendTest.cxx 
b/vcl/backendtest/VisualBackendTest.cxx
index 221f18254389..55fdd16712cc 100644
--- a/vcl/backendtest/VisualBackendTest.cxx
+++ b/vcl/backendtest/VisualBackendTest.cxx
@@ -830,7 +830,7 @@ public:
         {
             ScopedVclPtrInstance<VisualBackendTestWindow> aMainWindow;
 
-            aMainWindow->SetText("VCL Test");
+            aMainWindow->SetText(u"VCL Test"_ustr);
             aMainWindow->Show();
 
             Application::Execute();
@@ -857,7 +857,7 @@ protected:
             uno::Reference<lang::XMultiServiceFactory> 
xMSF(xComponentContext->getServiceManager(), uno::UNO_QUERY);
 
             if (!xMSF.is())
-                Application::Abort("Bootstrap failure - no service manager");
+                Application::Abort(u"Bootstrap failure - no service 
manager"_ustr);
 
             comphelper::setProcessServiceFactory(xMSF);
         }
diff --git a/vcl/backendtest/outputdevice/text.cxx 
b/vcl/backendtest/outputdevice/text.cxx
index 5e53d900babd..bdb78fca184b 100644
--- a/vcl/backendtest/outputdevice/text.cxx
+++ b/vcl/backendtest/outputdevice/text.cxx
@@ -22,12 +22,12 @@ Bitmap OutputDeviceTestText::setupTextBitmap()
     tools::Long midX = (maVDRectangle.Right() - maVDRectangle.Left()) / 2.0;
     tools::Long midY = (maVDRectangle.Bottom() - maVDRectangle.Top()) / 2.0;
 
-    vcl::Font Font("DejaVu Sans", "Book", Size(0, 10));
+    vcl::Font Font(u"DejaVu Sans"_ustr, u"Book"_ustr, Size(0, 10));
 
     mpVirtualDevice->Erase();
     mpVirtualDevice->SetFont(Font);
     mpVirtualDevice->SetTextColor(COL_LIGHTRED);
-    mpVirtualDevice->DrawText(Point(midX, midY - midY / 2), "I");
+    mpVirtualDevice->DrawText(Point(midX, midY - midY / 2), u"I"_ustr);
 
     return mpVirtualDevice->GetBitmap(maVDRectangle.TopLeft(), 
maVDRectangle.GetSize());
 }
diff --git a/vcl/headless/svpframe.cxx b/vcl/headless/svpframe.cxx
index c31ae5e89970..bae2312f2478 100644
--- a/vcl/headless/svpframe.cxx
+++ b/vcl/headless/svpframe.cxx
@@ -416,7 +416,7 @@ void SvpSalFrame::UpdateSettings( AllSettings& rSettings )
         vcl::Font aStdFont( FAMILY_SWISS, Size( 0, 14 ) );
         aStdFont.SetCharSet( osl_getThreadTextEncoding() );
         aStdFont.SetWeight( WEIGHT_NORMAL );
-        aStdFont.SetFamilyName( "Liberation Sans" );
+        aStdFont.SetFamilyName( u"Liberation Sans"_ustr );
         aStyleSettings.BatchSetFonts( aStdFont, aStdFont );
 
         aStdFont.SetFontSize(Size(0, 12));
diff --git a/vcl/headless/svpprn.cxx b/vcl/headless/svpprn.cxx
index 4d81b7c3fd1a..07321db86e9b 100644
--- a/vcl/headless/svpprn.cxx
+++ b/vcl/headless/svpprn.cxx
@@ -98,7 +98,7 @@ static void copyJobDataToJobSetup( ImplJobSetup* pJobSetup, 
JobData& rData )
 
     pJobSetup->SetPaperBin( 0xffff );
     if( rData.m_pParser )
-        pKey                    = rData.m_pParser->getKey( "InputSlot" );
+        pKey                    = rData.m_pParser->getKey( u"InputSlot"_ustr );
     if( pKey )
         pValue                  = rData.m_aContext.getValue( pKey );
     if( pKey && pValue )
@@ -120,7 +120,7 @@ static void copyJobDataToJobSetup( ImplJobSetup* pJobSetup, 
JobData& rData )
 
     pJobSetup->SetDuplexMode( DuplexMode::Unknown );
     if( rData.m_pParser )
-        pKey = rData.m_pParser->getKey( "Duplex" );
+        pKey = rData.m_pParser->getKey( u"Duplex"_ustr );
     if( pKey )
         pValue = rData.m_aContext.getValue( pKey );
     if( pKey && pValue )
diff --git a/vcl/inc/font/FontSelectPattern.hxx 
b/vcl/inc/font/FontSelectPattern.hxx
index 8e21cf5696bc..d95cc36ae07f 100644
--- a/vcl/inc/font/FontSelectPattern.hxx
+++ b/vcl/inc/font/FontSelectPattern.hxx
@@ -77,7 +77,7 @@ template< typename charT, typename traits >
 inline std::basic_ostream<charT, traits> & operator <<(
     std::basic_ostream<charT, traits> & stream, const 
vcl::font::FontSelectPattern & rFSP)
 {
-    stream << (rFSP.maTargetName.isEmpty() ? "<default>" : rFSP.maTargetName)
+    stream << (rFSP.maTargetName.isEmpty() ? u"<default>"_ustr : 
rFSP.maTargetName)
            << " (" << rFSP.maSearchName << ") w: " << rFSP.mnWidth << " h: "
            << rFSP.mnHeight << " alias: " << rFSP.mbNonAntialiased;
     return stream;
diff --git a/vcl/inc/headless/SvpGraphicsBackend.hxx 
b/vcl/inc/headless/SvpGraphicsBackend.hxx
index c193fbee4465..4475216148c0 100644
--- a/vcl/inc/headless/SvpGraphicsBackend.hxx
+++ b/vcl/inc/headless/SvpGraphicsBackend.hxx
@@ -38,7 +38,7 @@ public:
 
     void freeResources() override;
 
-    OUString getRenderBackendName() const override { return "svp"; }
+    OUString getRenderBackendName() const override { return u"svp"_ustr; }
 
     void setClipRegion(vcl::Region const& rRegion) override;
     void ResetClipRegion() override;
diff --git a/vcl/inc/qt5/QtGraphics.hxx b/vcl/inc/qt5/QtGraphics.hxx
index fce2b0d9b56d..5277fba33923 100644
--- a/vcl/inc/qt5/QtGraphics.hxx
+++ b/vcl/inc/qt5/QtGraphics.hxx
@@ -67,7 +67,7 @@ public:
 
     void freeResources() override {}
 
-    OUString getRenderBackendName() const override { return "qt5"; }
+    OUString getRenderBackendName() const override { return u"qt5"_ustr; }
 
     void setClipRegion(vcl::Region const& rRegion) override;
     void ResetClipRegion() override;
diff --git a/vcl/inc/qt5/QtSvpGraphics.hxx b/vcl/inc/qt5/QtSvpGraphics.hxx
index da3786eee165..f3e3de3394dd 100644
--- a/vcl/inc/qt5/QtSvpGraphics.hxx
+++ b/vcl/inc/qt5/QtSvpGraphics.hxx
@@ -48,7 +48,7 @@ public:
 
     virtual void GetResolution(sal_Int32& rDPIX, sal_Int32& rDPIY) override;
 
-    virtual OUString getRenderBackendName() const override { return "qt5svp"; }
+    virtual OUString getRenderBackendName() const override { return 
u"qt5svp"_ustr; }
 };
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/inc/salinst.hxx b/vcl/inc/salinst.hxx
index 124118f4e609..ca6a6920bf76 100644
--- a/vcl/inc/salinst.hxx
+++ b/vcl/inc/salinst.hxx
@@ -203,7 +203,7 @@ public:
     virtual void            releaseMainThread() {}
 
     /// get information about underlying versions
-    virtual OUString        getOSVersion() { return "-"; }
+    virtual OUString        getOSVersion() { return u"-"_ustr; }
 
     virtual const cairo_font_options_t* GetCairoFontOptions() { return 
nullptr; }
 
diff --git a/vcl/inc/skia/gdiimpl.hxx b/vcl/inc/skia/gdiimpl.hxx
index 71f5cce8aae6..0cd1a61b3ced 100644
--- a/vcl/inc/skia/gdiimpl.hxx
+++ b/vcl/inc/skia/gdiimpl.hxx
@@ -45,7 +45,7 @@ public:
 
     virtual void DeInit() override;
 
-    virtual OUString getRenderBackendName() const override { return "skia"; }
+    virtual OUString getRenderBackendName() const override { return 
u"skia"_ustr; }
 
     const vcl::Region& getClipRegion() const;
     virtual void setClipRegion(const vcl::Region&) override;
diff --git a/vcl/inc/unx/gtk/gtkgdi.hxx b/vcl/inc/unx/gtk/gtkgdi.hxx
index 9d8bb26ce787..d6430d2bb6e0 100644
--- a/vcl/inc/unx/gtk/gtkgdi.hxx
+++ b/vcl/inc/unx/gtk/gtkgdi.hxx
@@ -127,7 +127,7 @@ public:
 
     virtual void GetResolution(sal_Int32& rDPIX, sal_Int32& rDPIY) override;
 
-    virtual OUString getRenderBackendName() const override { return "gtk3svp"; 
}
+    virtual OUString getRenderBackendName() const override { return 
u"gtk3svp"_ustr; }
 
     GtkStyleContext* createStyleContext(GtkControlPart ePart);
 #if !GTK_CHECK_VERSION(4, 0, 0)
diff --git a/vcl/inc/vclstatuslistener.hxx b/vcl/inc/vclstatuslistener.hxx
index bc10456650b0..bea222ef83dd 100644
--- a/vcl/inc/vclstatuslistener.hxx
+++ b/vcl/inc/vclstatuslistener.hxx
@@ -61,7 +61,7 @@ void VclStatusListener<T>::startListening()
     if (!xDispatchProvider.is())
         return;
 
-    mxDispatch = xDispatchProvider->queryDispatch(maCommandURL, "", 0);
+    mxDispatch = xDispatchProvider->queryDispatch(maCommandURL, u""_ustr, 0);
     if (mxDispatch.is())
         mxDispatch->addStatusListener(this, maCommandURL);
 }
diff --git a/vcl/jsdialog/executor.cxx b/vcl/jsdialog/executor.cxx
index 3eebd350ef88..9df655b979a2 100644
--- a/vcl/jsdialog/executor.cxx
+++ b/vcl/jsdialog/executor.cxx
@@ -54,8 +54,8 @@ bool ExecuteAction(const OUString& nWindowId, const OUString& 
rWidget, StringMap
 {
     weld::Widget* pWidget = JSInstanceBuilder::FindWeldWidgetsMap(nWindowId, 
rWidget);
 
-    OUString sControlType = rData["type"];
-    OUString sAction = rData["cmd"];
+    OUString sControlType = rData[u"type"_ustr];
+    OUString sAction = rData[u"cmd"_ustr];
 
     if (sControlType == "responsebutton")
     {
@@ -63,7 +63,7 @@ bool ExecuteAction(const OUString& nWindowId, const OUString& 
rWidget, StringMap
         if (pWidget == nullptr || (pButton && 
!pButton->is_custom_handler_set()))
         {
             // welded wrapper not found - use response code instead
-            pWidget = JSInstanceBuilder::FindWeldWidgetsMap(nWindowId, 
"__DIALOG__");
+            pWidget = JSInstanceBuilder::FindWeldWidgetsMap(nWindowId, 
u"__DIALOG__"_ustr);
             sControlType = "dialog";
             sAction = "response";
         }
@@ -89,7 +89,7 @@ bool ExecuteAction(const OUString& nWindowId, const OUString& 
rWidget, StringMap
             {
                 if (sAction == "selecttab")
                 {
-                    sal_Int32 page = o3tl::toInt32(rData["data"]);
+                    sal_Int32 page = o3tl::toInt32(rData[u"data"_ustr]);
 
                     OUString aCurrentPage = 
pNotebook->get_current_page_ident();
                     LOKTrigger::leave_page(*pNotebook, aCurrentPage);
@@ -107,7 +107,7 @@ bool ExecuteAction(const OUString& nWindowId, const 
OUString& rWidget, StringMap
             {
                 if (sAction == "selected")
                 {
-                    OUString sSelectedData = rData["data"];
+                    OUString sSelectedData = rData[u"data"_ustr];
                     int separatorPos = sSelectedData.indexOf(';');
                     if (separatorPos > 0)
                     {
@@ -123,9 +123,9 @@ bool ExecuteAction(const OUString& nWindowId, const 
OUString& rWidget, StringMap
                     // it might be other class than JSComboBox
                     auto pJSCombobox = dynamic_cast<JSComboBox*>(pWidget);
                     if (pJSCombobox)
-                        
pJSCombobox->set_entry_text_without_notify(rData["data"]);
+                        
pJSCombobox->set_entry_text_without_notify(rData[u"data"_ustr]);
                     else
-                        pCombobox->set_entry_text(rData["data"]);
+                        pCombobox->set_entry_text(rData[u"data"_ustr]);
                     LOKTrigger::trigger_changed(*pCombobox);
                     return true;
                 }
@@ -135,7 +135,7 @@ bool ExecuteAction(const OUString& nWindowId, const 
OUString& rWidget, StringMap
                     if (pJSCombobox)
                     {
                         // pos;dpix;dpiy
-                        const OUString& sParams = rData["data"];
+                        const OUString& sParams = rData[u"data"_ustr];
                         const OUString aPos = sParams.getToken(0, ';');
                         const OUString aDpiScaleX = sParams.getToken(1, ';');
                         const OUString aDpiScaleY = sParams.getToken(2, ';');
@@ -196,7 +196,7 @@ bool ExecuteAction(const OUString& nWindowId, const 
OUString& rWidget, StringMap
                 }
                 else if (sAction == "select")
                 {
-                    LOKTrigger::trigger_selected(*pButton, rData["data"]);
+                    LOKTrigger::trigger_selected(*pButton, 
rData[u"data"_ustr]);
                     return true;
                 }
             }
@@ -208,7 +208,7 @@ bool ExecuteAction(const OUString& nWindowId, const 
OUString& rWidget, StringMap
             {
                 if (sAction == "change")
                 {
-                    bool bChecked = rData["data"] == "true";
+                    bool bChecked = rData[u"data"_ustr] == "true";
                     pCheckButton->set_state(bChecked ? TRISTATE_TRUE : 
TRISTATE_FALSE);
                     
LOKTrigger::trigger_toggled(*static_cast<weld::Toggleable*>(pCheckButton));
                     return true;
@@ -223,7 +223,7 @@ bool ExecuteAction(const OUString& nWindowId, const 
OUString& rWidget, StringMap
                 if (sAction == "click" || sAction == "dblclick" || sAction == 
"mousemove"
                     || sAction == "mousedown" || sAction == "mouseup")
                 {
-                    OUString sClickData = rData["data"];
+                    OUString sClickData = rData[u"data"_ustr];
                     int nSeparatorPos = sClickData.indexOf(';');
                     if (nSeparatorPos > 0)
                     {
@@ -260,14 +260,14 @@ bool ExecuteAction(const OUString& nWindowId, const 
OUString& rWidget, StringMap
                 }
                 else if (sAction == "keypress")
                 {
-                    sal_uInt32 nKeyNo = rData["data"].toUInt32();
+                    sal_uInt32 nKeyNo = rData[u"data"_ustr].toUInt32();
                     LOKTrigger::trigger_key_press(*pArea, KeyEvent(nKeyNo, 
vcl::KeyCode(nKeyNo)));
                     LOKTrigger::trigger_key_release(*pArea, KeyEvent(nKeyNo, 
vcl::KeyCode(nKeyNo)));
                     return true;
                 }
                 else if (sAction == "textselection")
                 {
-                    OUString sTextData = rData["data"];
+                    OUString sTextData = rData[u"data"_ustr];
                     int nSeparatorPos = sTextData.indexOf(';');
                     if (nSeparatorPos <= 0)
                         return true;
@@ -335,14 +335,14 @@ bool ExecuteAction(const OUString& nWindowId, const 
OUString& rWidget, StringMap
             {
                 if (sAction == "change" || sAction == "value")
                 {
-                    if (rData["data"] == "undefined")
+                    if (rData[u"data"_ustr] == "undefined")
                         return true;
 
                     // The Document will not scroll if that is in focus
                     // maybe we could send a message with: sAction == 
"grab_focus"
                     pWidget->grab_focus();
 
-                    double nValue = o3tl::toDouble(rData["data"]);
+                    double nValue = o3tl::toDouble(rData[u"data"_ustr]);
                     pSpinField->set_value(nValue
                                           * 
weld::SpinButton::Power10(pSpinField->get_digits()));
                     LOKTrigger::trigger_value_changed(*pSpinField);
@@ -367,7 +367,7 @@ bool ExecuteAction(const OUString& nWindowId, const 
OUString& rWidget, StringMap
             {
                 if (sAction == "change")
                 {
-                    pFormattedField->set_text(rData["data"]);
+                    pFormattedField->set_text(rData[u"data"_ustr]);
                     LOKTrigger::trigger_changed(*pFormattedField);
                     LOKTrigger::trigger_value_changed(*pFormattedField);
                     return true;
@@ -381,24 +381,24 @@ bool ExecuteAction(const OUString& nWindowId, const 
OUString& rWidget, StringMap
             {
                 if (sAction == "click")
                 {
-                    LOKTrigger::trigger_clicked(*pToolbar, rData["data"]);
+                    LOKTrigger::trigger_clicked(*pToolbar, 
rData[u"data"_ustr]);
                     return true;
                 }
                 else if (sAction == "togglemenu")
                 {
-                    const OUString& sId = rData["data"];
+                    const OUString& sId = rData[u"data"_ustr];
                     bool bIsActive = pToolbar->get_menu_item_active(sId);
                     pToolbar->set_menu_item_active(sId, !bIsActive);
                     return true;
                 }
                 else if (sAction == "closemenu")
                 {
-                    pToolbar->set_menu_item_active(rData["data"], false);
+                    pToolbar->set_menu_item_active(rData[u"data"_ustr], false);
                     return true;
                 }
                 else if (sAction == "openmenu")
                 {
-                    pToolbar->set_menu_item_active(rData["data"], true);
+                    pToolbar->set_menu_item_active(rData[u"data"_ustr], true);
                     return true;
                 }
             }
@@ -410,7 +410,7 @@ bool ExecuteAction(const OUString& nWindowId, const 
OUString& rWidget, StringMap
             {
                 if (sAction == "change")
                 {
-                    pEdit->set_text_without_notify(rData["data"]);
+                    pEdit->set_text_without_notify(rData[u"data"_ustr]);
                     LOKTrigger::trigger_changed(*pEdit);
                     return true;
                 }
@@ -423,7 +423,7 @@ bool ExecuteAction(const OUString& nWindowId, const 
OUString& rWidget, StringMap
                 {
                     int rStartPos, rEndPos;
                     pTextView->get_selection_bounds(rStartPos, rEndPos);
-                    pTextView->set_text_without_notify(rData["data"]);
+                    pTextView->set_text_without_notify(rData[u"data"_ustr]);
                     pTextView->select_region(rStartPos, rEndPos);
                     LOKTrigger::trigger_changed(*pTextView);
                     return true;
@@ -431,7 +431,7 @@ bool ExecuteAction(const OUString& nWindowId, const 
OUString& rWidget, StringMap
                 else if (sAction == "textselection")
                 {
                     // start;end
-                    OUString sTextData = rData["data"];
+                    OUString sTextData = rData[u"data"_ustr];
                     int nSeparatorPos = sTextData.indexOf(';');
                     if (nSeparatorPos <= 0)
                         return true;
@@ -460,13 +460,13 @@ bool ExecuteAction(const OUString& nWindowId, const 
OUString& rWidget, StringMap
                 if (sAction == "change")
                 {
                     OUString sDataJSON = rtl::Uri::decode(
-                        rData["data"], 
rtl_UriDecodeMechanism::rtl_UriDecodeWithCharset,
+                        rData[u"data"_ustr], 
rtl_UriDecodeMechanism::rtl_UriDecodeWithCharset,
                         RTL_TEXTENCODING_UTF8);
                     StringMap aMap(jsonToStringMap(
                         OUStringToOString(sDataJSON, 
RTL_TEXTENCODING_ASCII_US).getStr()));
 
-                    sal_Int32 nRow = o3tl::toInt32(aMap["row"]);
-                    bool bValue = aMap["value"] == "true";
+                    sal_Int32 nRow = o3tl::toInt32(aMap[u"row"_ustr]);
+                    bool bValue = aMap[u"value"_ustr] == "true";
 
                     pTreeView->set_toggle(nRow, bValue ? TRISTATE_TRUE : 
TRISTATE_FALSE);
 
@@ -474,7 +474,7 @@ bool ExecuteAction(const OUString& nWindowId, const 
OUString& rWidget, StringMap
                 }
                 else if (sAction == "select")
                 {
-                    sal_Int32 nAbsPos = o3tl::toInt32(rData["data"]);
+                    sal_Int32 nAbsPos = o3tl::toInt32(rData[u"data"_ustr]);
 
                     pTreeView->unselect_all();
 
@@ -493,7 +493,7 @@ bool ExecuteAction(const OUString& nWindowId, const 
OUString& rWidget, StringMap
                 }
                 else if (sAction == "activate")
                 {
-                    sal_Int32 nRow = o3tl::toInt32(rData["data"]);
+                    sal_Int32 nRow = o3tl::toInt32(rData[u"data"_ustr]);
 
                     pTreeView->unselect_all();
                     std::unique_ptr<weld::TreeIter> 
itEntry(pTreeView->make_iterator());
@@ -512,7 +512,7 @@ bool ExecuteAction(const OUString& nWindowId, const 
OUString& rWidget, StringMap
                 }
                 else if (sAction == "expand")
                 {
-                    sal_Int32 nAbsPos = o3tl::toInt32(rData["data"]);
+                    sal_Int32 nAbsPos = o3tl::toInt32(rData[u"data"_ustr]);
                     std::unique_ptr<weld::TreeIter> 
itEntry(pTreeView->make_iterator());
                     if (pTreeView->get_iter_abs_pos(*itEntry, nAbsPos))
                     {
@@ -527,7 +527,7 @@ bool ExecuteAction(const OUString& nWindowId, const 
OUString& rWidget, StringMap
                 }
                 else if (sAction == "collapse")
                 {
-                    sal_Int32 nAbsPos = o3tl::toInt32(rData["data"]);
+                    sal_Int32 nAbsPos = o3tl::toInt32(rData[u"data"_ustr]);
                     std::unique_ptr<weld::TreeIter> 
itEntry(pTreeView->make_iterator());
                     if (pTreeView->get_iter_abs_pos(*itEntry, nAbsPos))
                     {
@@ -542,7 +542,7 @@ bool ExecuteAction(const OUString& nWindowId, const 
OUString& rWidget, StringMap
                 }
                 else if (sAction == "dragstart")
                 {
-                    sal_Int32 nRow = o3tl::toInt32(rData["data"]);
+                    sal_Int32 nRow = o3tl::toInt32(rData[u"data"_ustr]);
 
                     pTreeView->select(nRow);
                     pTreeView->drag_start();
@@ -563,7 +563,7 @@ bool ExecuteAction(const OUString& nWindowId, const 
OUString& rWidget, StringMap
             {
                 if (sAction == "select")
                 {
-                    sal_Int32 nPos = o3tl::toInt32(rData["data"]);
+                    sal_Int32 nPos = o3tl::toInt32(rData[u"data"_ustr]);
 
                     pIconView->select(nPos);
                     LOKTrigger::trigger_changed(*pIconView);
@@ -572,7 +572,7 @@ bool ExecuteAction(const OUString& nWindowId, const 
OUString& rWidget, StringMap
                 }
                 else if (sAction == "activate")
                 {
-                    sal_Int32 nPos = o3tl::toInt32(rData["data"]);
+                    sal_Int32 nPos = o3tl::toInt32(rData[u"data"_ustr]);
 
                     pIconView->select(nPos);
                     LOKTrigger::trigger_changed(*pIconView);
@@ -606,7 +606,7 @@ bool ExecuteAction(const OUString& nWindowId, const 
OUString& rWidget, StringMap
                 }
                 else if (sAction == "response")
                 {
-                    sal_Int32 nResponse = o3tl::toInt32(rData["data"]);
+                    sal_Int32 nResponse = o3tl::toInt32(rData[u"data"_ustr]);
                     pDialog->response(nResponse);
                     return true;
                 }
@@ -631,7 +631,7 @@ bool ExecuteAction(const OUString& nWindowId, const 
OUString& rWidget, StringMap
             {
                 if (sAction == "change")
                 {
-                    bool bChecked = rData["data"] == "true";
+                    bool bChecked = rData[u"data"_ustr] == "true";
                     pRadioButton->set_state(bChecked ? TRISTATE_TRUE : 
TRISTATE_FALSE);
                     
LOKTrigger::trigger_toggled(*static_cast<weld::Toggleable*>(pRadioButton));
                     return true;
@@ -645,14 +645,14 @@ bool ExecuteAction(const OUString& nWindowId, const 
OUString& rWidget, StringMap
             {
                 if (sAction == "scrollv")
                 {
-                    sal_Int32 nValue = o3tl::toInt32(rData["data"]);
+                    sal_Int32 nValue = o3tl::toInt32(rData[u"data"_ustr]);
                     
pScrolledWindow->vadjustment_set_value_no_notification(nValue);
                     LOKTrigger::trigger_scrollv(*pScrolledWindow);
                     return true;
                 }
                 else if (sAction == "scrollh")
                 {
-                    sal_Int32 nValue = o3tl::toInt32(rData["data"]);
+                    sal_Int32 nValue = o3tl::toInt32(rData[u"data"_ustr]);
                     
pScrolledWindow->hadjustment_set_value_no_notification(nValue);
                     LOKTrigger::trigger_scrollh(*pScrolledWindow);
                     return true;
@@ -665,7 +665,7 @@ bool ExecuteAction(const OUString& nWindowId, const 
OUString& rWidget, StringMap
             if (pCalendar && sAction == "selectdate")
             {
                 // MM/DD/YYYY
-                OUString aDate = rData["data"];
+                OUString aDate = rData[u"data"_ustr];
 
                 if (aDate.getLength() < 10)
                     return false;
diff --git a/vcl/jsdialog/jsdialogbuilder.cxx b/vcl/jsdialog/jsdialogbuilder.cxx
index d4767a4f3311..634dc54d8c04 100644
--- a/vcl/jsdialog/jsdialogbuilder.cxx
+++ b/vcl/jsdialog/jsdialogbuilder.cxx
@@ -439,7 +439,7 @@ void JSDropTarget::setDefaultActions(sal_Int8 /*actions*/) 
{}
 
 OUString JSDropTarget::getImplementationName()
 {
-    return "com.sun.star.datatransfer.dnd.JSDropTarget";
+    return u"com.sun.star.datatransfer.dnd.JSDropTarget"_ustr;
 }
 
 sal_Bool JSDropTarget::supportsService(OUString const& ServiceName)
@@ -449,7 +449,7 @@ sal_Bool JSDropTarget::supportsService(OUString const& 
ServiceName)
 
 css::uno::Sequence<OUString> JSDropTarget::getSupportedServiceNames()
 {
-    css::uno::Sequence<OUString> aRet{ 
"com.sun.star.datatransfer.dnd.JSDropTarget" };
+    css::uno::Sequence<OUString> aRet{ 
u"com.sun.star.datatransfer.dnd.JSDropTarget"_ustr };
     return aRet;
 }
 
@@ -495,7 +495,7 @@ JSInstanceBuilder::JSInstanceBuilder(weld::Widget* pParent, 
const OUString& rUIR
     , m_nWindowId(0)
     , m_aParentDialog(nullptr)
     , m_aContentWindow(nullptr)
-    , m_sTypeOfJSON("dialog")
+    , m_sTypeOfJSON(u"dialog"_ustr)
     , m_bHasTopLevelDialog(false)
     , m_bIsNotebookbar(false)
     , m_bSentInitialUpdate(false)
@@ -529,7 +529,7 @@ JSInstanceBuilder::JSInstanceBuilder(weld::Widget* pParent, 
const OUString& rUIR
     , m_nWindowId(nLOKWindowId)
     , m_aParentDialog(nullptr)
     , m_aContentWindow(nullptr)
-    , m_sTypeOfJSON("sidebar")
+    , m_sTypeOfJSON(u"sidebar"_ustr)
     , m_bHasTopLevelDialog(false)
     , m_bIsNotebookbar(false)
     , m_bSentInitialUpdate(false)
@@ -573,7 +573,7 @@ JSInstanceBuilder::JSInstanceBuilder(vcl::Window* pParent, 
const OUString& rUIRo
     , m_nWindowId(0)
     , m_aParentDialog(nullptr)
     , m_aContentWindow(nullptr)
-    , m_sTypeOfJSON("notebookbar")
+    , m_sTypeOfJSON(u"notebookbar"_ustr)
     , m_bHasTopLevelDialog(false)
     , m_bIsNotebookbar(false)
     , m_bSentInitialUpdate(false)
@@ -604,7 +604,7 @@ JSInstanceBuilder::JSInstanceBuilder(vcl::Window* pParent, 
const OUString& rUIRo
     , m_nWindowId(nLOKWindowId)
     , m_aParentDialog(nullptr)
     , m_aContentWindow(nullptr)
-    , m_sTypeOfJSON("formulabar")
+    , m_sTypeOfJSON(u"formulabar"_ustr)
     , m_bHasTopLevelDialog(false)
     , m_bIsNotebookbar(false)
     , m_bSentInitialUpdate(false)
@@ -663,7 +663,7 @@ JSInstanceBuilder::~JSInstanceBuilder()
     // tab page closed -> refresh parent window
     if (m_bIsNestedBuilder && m_sTypeOfJSON == "dialog")
     {
-        jsdialog::SendFullUpdate(OUString::number(m_nWindowId), "__DIALOG__");
-e 
... etc. - the rest is truncated

Reply via email to