vcl/qa/cppunit/BackendTest.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  */
  10
  11 #include <test/bootstrapfixture.hxx>
  12
  13 #include <vcl/bitmap.hxx>
  14 #include <tools/stream.hxx>
  15 #include <vcl/graphicfilter.hxx>
  16 #include <basegfx/matrix/b2dhommatrix.hxx>
  17 #include <vcl/BitmapWriteAccess.hxx>
  18
  19 #include <svdata.hxx>
  20 #include <salinst.hxx>
  21 #include <salgdi.hxx>
  22
  23 #include <test/outputdevice.hxx>
  24
  25 // Run tests from visualbackendtest ('bin/run visualbackendtest').
  26 class BackendTest : public test::BootstrapFixture
  27 {
  28     // if enabled - check the result images with:
  29     // "xdg-open ./workdir/CppunitTest/vcl_backend_test.test.core/"
  30     static constexpr const bool mbExportBitmap = false;
  31
  32     void exportImage(OUString const& rsFilename, BitmapEx const& rBitmapEx)
  33     {
  34         if (mbExportBitmap)
  35         {
  36             BitmapEx aBitmapEx(rBitmapEx);
  37             aBitmapEx.Scale(Size(128, 128), BmpScaleFlag::Fast);
  38             SvFileStream aStream(rsFilename, StreamMode::WRITE | StreamMode::TRUNC);
  39             GraphicFilter::GetGraphicFilter().compressAsPNG(aBitmapEx, aStream);
  40         }
  41     }
  42
  43     void exportImage(OUString const& rsFilename, Bitmap const& rBitmap)
  44     {
  45         if (mbExportBitmap)
  46         {
  47             Bitmap aBitmap(rBitmap);
  48             aBitmap.Scale(Size(128, 128), BmpScaleFlag::Fast);
  49             SvFileStream aStream(rsFilename, StreamMode::WRITE | StreamMode::TRUNC);
  50             GraphicFilter::GetGraphicFilter().compressAsPNG(BitmapEx(aBitmap), aStream);
  51         }
  52     }
  53
  54     void exportDevice(const OUString& filename, const VclPtr<VirtualDevice>& device)
  55     {
  56         if (mbExportBitmap)
  57         {
  58             BitmapEx aBitmapEx(device->GetBitmapEx(Point(0, 0), device->GetOutputSizePixel()));
  59             SvFileStream aStream(filename, StreamMode::WRITE | StreamMode::TRUNC);
  60             GraphicFilter::GetGraphicFilter().compressAsPNG(aBitmapEx, aStream);
  61         }
  62     }
  63
  64     bool is32bppSupported() { return ImplGetSVData()->mpDefInst->supportsBitmap32(); }
  65
  66 public:
  67     BackendTest()
  68         : BootstrapFixture(true, false)
  69     {
  70     }
  71
  72     // We need to enable tests ONE BY ONE as they fail because of backend bugs
  73     // it is still important to have the test defined so we know the issues
  74     // exist and we need to fix them. Consistent behaviour of our backends
  75     // is of highest priority.
  76
  77     static bool assertBackendNameNotEmpty(const OUString& name)
  78     {
  79         // This ensures that all backends return a valid name.
  80         assert(!name.isEmpty());
  81         (void)name;
  82         return true;
  83     }
  84
  85 // Check whether tests should fail depending on which backend is used
  86 // (not all work). If you want to disable just a specific test
  87 // for a specific backend, use something like
  88 // 'if(SHOULD_ASSERT && aOutDevTest.getRenderBackendName() != "skia")'.
  89 // The macro uses opt-out rather than opt-in so that this doesn't "pass"
  90 // silently in case a new backend is added.
  91 #define SHOULD_ASSERT                                                                              \
  92     (assertBackendNameNotEmpty(aOutDevTest.getRenderBackendName())                                 \
  93      && aOutDevTest.getRenderBackendName() != "qt"                                                 \
  94      && aOutDevTest.getRenderBackendName() != "qtsvp"                                              \
  95      && aOutDevTest.getRenderBackendName() != "gtk3svp"                                            \
  96      && aOutDevTest.getRenderBackendName() != "aqua"                                               \
  97      && aOutDevTest.getRenderBackendName() != "gen"                                                \
  98      && aOutDevTest.getRenderBackendName() != "genpsp"                                             \
  99      && aOutDevTest.getRenderBackendName() != "win")
 100
 101 #ifdef MACOSX
 102     static OUString getRenderBackendName(OutputDevice* device)
 103     {
 104         assert(device);
 105         return device->GetGraphics()->getRenderBackendName();
 106     }
 107 #endif
 108
 109     void testDrawRectWithRectangle()
 110     {
 111         if (getDefaultDeviceBitCount() < 24)
 112             return;
 113         vcl::test::OutputDeviceTestRect aOutDevTest;
 114         Bitmap aBitmap = aOutDevTest.setupRectangle(false);
 115         auto eResult = vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
 116         exportImage(u"01-01_rectangle_test-rectangle.png"_ustr, aBitmap);
 117
 118         if (SHOULD_ASSERT)
 119             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 120     }
 121
 122     void testDrawRectWithPixel()
 123     {
 124         if (getDefaultDeviceBitCount() < 24)
 125             return;
 126         vcl::test::OutputDeviceTestPixel aOutDevTest;
 127         Bitmap aBitmap = aOutDevTest.setupRectangle(false);
 128         auto eResult = vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
 129         exportImage(u"01-02_rectangle_test-pixel.png"_ustr, aBitmap);
 130
 131         if (SHOULD_ASSERT)
 132             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 133     }
 134
 135     void testDrawRectWithLine()
 136     {
 137         if (getDefaultDeviceBitCount() < 24)
 138             return;
 139         vcl::test::OutputDeviceTestLine aOutDevTest;
 140         Bitmap aBitmap = aOutDevTest.setupRectangle(false);
 141         auto eResult = vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
 142         exportImage(u"01-03_rectangle_test-line.png"_ustr, aBitmap);
 143
 144         if (SHOULD_ASSERT)
 145             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 146     }
 147
 148     void testDrawRectWithPolygon()
 149     {
 150         if (getDefaultDeviceBitCount() < 24)
 151             return;
 152         vcl::test::OutputDeviceTestPolygon aOutDevTest;
 153         Bitmap aBitmap = aOutDevTest.setupRectangle(false);
 154         auto eResult = vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
 155         exportImage(u"01-04_rectangle_test-polygon.png"_ustr, aBitmap);
 156         if (SHOULD_ASSERT)
 157             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 158     }
 159
 160     void testDrawRectWithPolyLine()
 161     {
 162         if (getDefaultDeviceBitCount() < 24)
 163             return;
 164         vcl::test::OutputDeviceTestPolyLine aOutDevTest;
 165         Bitmap aBitmap = aOutDevTest.setupRectangle(false);
 166         auto eResult = vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
 167         exportImage(u"01-05_rectangle_test-polyline.png"_ustr, aBitmap);
 168         if (SHOULD_ASSERT)
 169             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 170     }
 171
 172     void testDrawRectWithPolyLineB2D()
 173     {
 174         if (getDefaultDeviceBitCount() < 24)
 175             return;
 176         vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
 177         Bitmap aBitmap = aOutDevTest.setupRectangle(false);
 178         auto eResult = vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
 179         exportImage(u"01-06_rectangle_test-polyline_b2d.png"_ustr, aBitmap);
 180         if (SHOULD_ASSERT)
 181             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 182     }
 183
 184     void testDrawRectWithPolyPolygon()
 185     {
 186         if (getDefaultDeviceBitCount() < 24)
 187             return;
 188         vcl::test::OutputDeviceTestPolyPolygon aOutDevTest;
 189         Bitmap aBitmap = aOutDevTest.setupRectangle(false);
 190         auto eResult = vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
 191         exportImage(u"01-07_rectangle_test-polypolygon.png"_ustr, aBitmap);
 192         if (SHOULD_ASSERT)
 193             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 194     }
 195
 196     void testDrawRectWithPolyPolygonB2D()
 197     {
 198         if (getDefaultDeviceBitCount() < 24)
 199             return;
 200         vcl::test::OutputDeviceTestPolyPolygonB2D aOutDevTest;
 201         Bitmap aBitmap = aOutDevTest.setupRectangle(false);
 202         auto eResult = vcl::test::OutputDeviceTestCommon::checkRectangles(aBitmap);
 203         exportImage(u"01-08_rectangle_test-polypolygon_b2d.png"_ustr, aBitmap);
 204         if (SHOULD_ASSERT)
 205             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 206     }
 207
 208     void testDrawRectAAWithRectangle()
 209     {
 210         if (getDefaultDeviceBitCount() < 24)
 211             return;
 212         vcl::test::OutputDeviceTestRect aOutDevTest;
 213         Bitmap aBitmap = aOutDevTest.setupRectangle(true);
 214         auto eResult = vcl::test::OutputDeviceTestCommon::checkRectangleAA(aBitmap);
 215         exportImage(u"02-01_rectangle_AA_test-rectangle.png"_ustr, aBitmap);
 216         if (SHOULD_ASSERT)
 217             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 218     }
 219
 220     void testDrawRectAAWithPixel()
 221     {
 222         if (getDefaultDeviceBitCount() < 24)
 223             return;
 224         vcl::test::OutputDeviceTestPixel aOutDevTest;
 225         Bitmap aBitmap = aOutDevTest.setupRectangle(true);
 226         auto eResult = vcl::test::OutputDeviceTestCommon::checkRectangleAA(aBitmap);
 227         exportImage(u"02-02_rectangle_AA_test-pixel.png"_ustr, aBitmap);
 228         if (SHOULD_ASSERT)
 229             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 230     }
 231
 232     void testDrawRectAAWithLine()
 233     {
 234         if (getDefaultDeviceBitCount() < 24)
 235             return;
 236         vcl::test::OutputDeviceTestLine aOutDevTest;
 237         Bitmap aBitmap = aOutDevTest.setupRectangle(true);
 238         auto eResult = vcl::test::OutputDeviceTestCommon::checkRectangleAA(aBitmap);
 239         exportImage(u"02-03_rectangle_AA_test-line.png"_ustr, aBitmap);
 240         if (SHOULD_ASSERT)
 241             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 242     }
 243
 244     void testDrawRectAAWithPolygon()
 245     {
 246         if (getDefaultDeviceBitCount() < 24)
 247             return;
 248         vcl::test::OutputDeviceTestPolygon aOutDevTest;
 249         Bitmap aBitmap = aOutDevTest.setupRectangle(true);
 250         auto eResult = vcl::test::OutputDeviceTestCommon::checkRectangleAA(aBitmap);
 251         exportImage(u"02-04_rectangle_AA_test-polygon.png"_ustr, aBitmap);
 252         if (SHOULD_ASSERT)
 253             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 254     }
 255
 256     void testDrawRectAAWithPolyLine()
 257     {
 258         if (getDefaultDeviceBitCount() < 24)
 259             return;
 260         vcl::test::OutputDeviceTestPolyLine aOutDevTest;
 261         Bitmap aBitmap = aOutDevTest.setupRectangle(true);
 262         auto eResult = vcl::test::OutputDeviceTestCommon::checkRectangleAA(aBitmap);
 263         exportImage(u"02-05_rectangle_AA_test-polyline.png"_ustr, aBitmap);
 264         if (SHOULD_ASSERT)
 265             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 266     }
 267
 268     void testDrawRectAAWithPolyLineB2D()
 269     {
 270         if (getDefaultDeviceBitCount() < 24)
 271             return;
 272         vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
 273         Bitmap aBitmap = aOutDevTest.setupRectangle(true);
 274         auto eResult = vcl::test::OutputDeviceTestCommon::checkRectangleAA(aBitmap);
 275         exportImage(u"02-06_rectangle_AA_test-polyline_b2d.png"_ustr, aBitmap);
 276         if (SHOULD_ASSERT)
 277             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 278     }
 279
 280     void testDrawRectAAWithPolyPolygon()
 281     {
 282         if (getDefaultDeviceBitCount() < 24)
 283             return;
 284         vcl::test::OutputDeviceTestPolyPolygon aOutDevTest;
 285         Bitmap aBitmap = aOutDevTest.setupRectangle(true);
 286         auto eResult = vcl::test::OutputDeviceTestCommon::checkRectangleAA(aBitmap);
 287         exportImage(u"02-07_rectangle_AA_test-polypolygon.png"_ustr, aBitmap);
 288         if (SHOULD_ASSERT)
 289             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 290     }
 291
 292     void testDrawRectAAWithPolyPolygonB2D()
 293     {
 294         if (getDefaultDeviceBitCount() < 24)
 295             return;
 296         vcl::test::OutputDeviceTestPolyPolygonB2D aOutDevTest;
 297         Bitmap aBitmap = aOutDevTest.setupRectangle(true);
 298         auto eResult = vcl::test::OutputDeviceTestCommon::checkRectangleAA(aBitmap);
 299         exportImage(u"02-08_rectangle_AA_test-polypolygon_b2d.png"_ustr, aBitmap);
 300         if (SHOULD_ASSERT)
 301             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 302     }
 303
 304     void testDrawFilledRectWithRectangle()
 305     {
 306         if (getDefaultDeviceBitCount() < 24)
 307             return;
 308         vcl::test::OutputDeviceTestRect aOutDevTest;
 309         Bitmap aBitmap = aOutDevTest.setupFilledRectangle(false);
 310         auto eResult = vcl::test::OutputDeviceTestCommon::checkFilledRectangle(aBitmap, false);
 311         exportImage(u"03-01_filled_rectangle_test-rectangle_noline.png"_ustr, aBitmap);
 312         if (SHOULD_ASSERT)
 313             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 314         aBitmap = aOutDevTest.setupFilledRectangle(true);
 315         eResult = vcl::test::OutputDeviceTestCommon::checkFilledRectangle(aBitmap, true);
 316         exportImage(u"03-01_filled_rectangle_test-rectangle_line.png"_ustr, aBitmap);
 317         if (SHOULD_ASSERT)
 318             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 319     }
 320
 321     void testDrawFilledRectWithPolygon()
 322     {
 323         if (getDefaultDeviceBitCount() < 24)
 324             return;
 325         vcl::test::OutputDeviceTestPolygon aOutDevTest;
 326         Bitmap aBitmap = aOutDevTest.setupFilledRectangle(false);
 327         auto eResult = vcl::test::OutputDeviceTestCommon::checkFilledRectangle(aBitmap, false);
 328         exportImage(u"03-02_filled_rectangle_test-polygon_noline.png"_ustr, aBitmap);
 329         if (SHOULD_ASSERT)
 330             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 331         aBitmap = aOutDevTest.setupFilledRectangle(true);
 332         eResult = vcl::test::OutputDeviceTestCommon::checkFilledRectangle(aBitmap, true);
 333         exportImage(u"03-02_filled_rectangle_test-polygon_line.png"_ustr, aBitmap);
 334         if (SHOULD_ASSERT)
 335             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 336     }
 337
 338     void testDrawFilledRectWithPolyPolygon()
 339     {
 340         if (getDefaultDeviceBitCount() < 24)
 341             return;
 342         vcl::test::OutputDeviceTestPolyPolygon aOutDevTest;
 343         Bitmap aBitmap = aOutDevTest.setupFilledRectangle(false);
 344         auto eResult = vcl::test::OutputDeviceTestCommon::checkFilledRectangle(aBitmap, false);
 345         exportImage(u"03-03_filled_rectangle_test-polypolygon_noline.png"_ustr, aBitmap);
 346         if (SHOULD_ASSERT)
 347             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 348         aBitmap = aOutDevTest.setupFilledRectangle(true);
 349         eResult = vcl::test::OutputDeviceTestCommon::checkFilledRectangle(aBitmap, true);
 350         exportImage(u"03-03_filled_rectangle_test-polypolygon_line.png"_ustr, aBitmap);
 351         if (SHOULD_ASSERT)
 352             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 353     }
 354
 355     void testDrawFilledRectWithPolyPolygon2D()
 356     {
 357         if (getDefaultDeviceBitCount() < 24)
 358             return;
 359         vcl::test::OutputDeviceTestPolyPolygonB2D aOutDevTest;
 360         Bitmap aBitmap = aOutDevTest.setupFilledRectangle(false);
 361         auto eResult = vcl::test::OutputDeviceTestCommon::checkFilledRectangle(aBitmap, false);
 362         exportImage(u"03-04_filled_rectangle_test-polypolygon_b2d_noline.png"_ustr, aBitmap);
 363         if (SHOULD_ASSERT)
 364             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 365         aBitmap = aOutDevTest.setupFilledRectangle(true);
 366         eResult = vcl::test::OutputDeviceTestCommon::checkFilledRectangle(aBitmap, true);
 367         exportImage(u"03-04_filled_rectangle_test-polypolygon_b2d_line.png"_ustr, aBitmap);
 368         if (SHOULD_ASSERT)
 369             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 370     }
 371
 372     void testDrawDiamondWithPolygon()
 373     {
 374         vcl::test::OutputDeviceTestPolygon aOutDevTest;
 375         Bitmap aBitmap = aOutDevTest.setupDiamond();
 376         auto eResult = vcl::test::OutputDeviceTestCommon::checkDiamond(aBitmap);
 377         exportImage(u"04-01_diamond_test-polygon.png"_ustr, aBitmap);
 378         if (SHOULD_ASSERT)
 379             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 380     }
 381
 382     void testDrawDiamondWithLine()
 383     {
 384         vcl::test::OutputDeviceTestLine aOutDevTest;
 385         Bitmap aBitmap = aOutDevTest.setupDiamond();
 386         auto eResult = vcl::test::OutputDeviceTestCommon::checkDiamond(aBitmap);
 387         exportImage(u"04-02_diamond_test-line.png"_ustr, aBitmap);
 388         if (SHOULD_ASSERT)
 389             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 390     }
 391
 392     void testDrawDiamondWithPolyline()
 393     {
 394         vcl::test::OutputDeviceTestPolyLine aOutDevTest;
 395         Bitmap aBitmap = aOutDevTest.setupDiamond();
 396         auto eResult = vcl::test::OutputDeviceTestCommon::checkDiamond(aBitmap);
 397         exportImage(u"04-03_diamond_test-polyline.png"_ustr, aBitmap);
 398         if (SHOULD_ASSERT)
 399             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 400     }
 401
 402     void testDrawDiamondWithPolylineB2D()
 403     {
 404         vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
 405         Bitmap aBitmap = aOutDevTest.setupDiamond();
 406         auto eResult = vcl::test::OutputDeviceTestCommon::checkDiamond(aBitmap);
 407         exportImage(u"04-04_diamond_test-polyline_b2d.png"_ustr, aBitmap);
 408         if (SHOULD_ASSERT)
 409             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 410     }
 411
 412     void testDrawInvertWithRectangle()
 413     {
 414         vcl::test::OutputDeviceTestRect aOutDevTest;
 415         Bitmap aBitmap = aOutDevTest.setupInvert_NONE();
 416         auto eResult = vcl::test::OutputDeviceTestCommon::checkInvertRectangle(aBitmap);
 417         exportImage(u"05-01_invert_test-rectangle.png"_ustr, aBitmap);
 418         if (SHOULD_ASSERT)
 419             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 420     }
 421
 422     void testDrawInvertN50WithRectangle()
 423     {
 424         vcl::test::OutputDeviceTestRect aOutDevTest;
 425         Bitmap aBitmap = aOutDevTest.setupInvert_N50();
 426         auto eResult = vcl::test::OutputDeviceTestCommon::checkInvertN50Rectangle(aBitmap);
 427         exportImage(u"05-02_invert_N50_test-rectangle.png"_ustr, aBitmap);
 428         if (SHOULD_ASSERT && aOutDevTest.getRenderBackendName() != "svp")
 429             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 430     }
 431
 432     void testDrawInvertTrackFrameWithRectangle()
 433     {
 434         vcl::test::OutputDeviceTestRect aOutDevTest;
 435         Bitmap aBitmap = aOutDevTest.setupInvert_TrackFrame();
 436         auto eResult = vcl::test::OutputDeviceTestCommon::checkInvertTrackFrameRectangle(aBitmap);
 437         exportImage(u"05-03_invert_TrackFrame_test-rectangle.png"_ustr, aBitmap);
 438         if (SHOULD_ASSERT && aOutDevTest.getRenderBackendName() != "svp")
 439             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 440     }
 441
 442     void testDrawBezierWithPolylineB2D()
 443     {
 444         if (getDefaultDeviceBitCount() < 24)
 445             return;
 446         vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
 447         Bitmap aBitmap = aOutDevTest.setupBezier();
 448         auto eResult = vcl::test::OutputDeviceTestCommon::checkBezier(aBitmap);
 449         exportImage(u"06-01_bezier_test-polyline_b2d.png"_ustr, aBitmap);
 450         if (SHOULD_ASSERT)
 451             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 452     }
 453
 454     void testDrawBezierAAWithPolylineB2D()
 455     {
 456         if (getDefaultDeviceBitCount() < 24)
 457             return;
 458         vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
 459         Bitmap aBitmap = aOutDevTest.setupAABezier();
 460         auto eResult = vcl::test::OutputDeviceTestCommon::checkBezier(aBitmap);
 461         exportImage(u"07-01_bezier_AA_test-polyline_b2d.png"_ustr, aBitmap);
 462         if (SHOULD_ASSERT)
 463             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 464     }
 465
 466     void testDrawBitmap24bpp()
 467     {
 468         if (getDefaultDeviceBitCount() < 24)
 469             return;
 470         vcl::test::OutputDeviceTestBitmap aOutDevTest;
 471         Bitmap aBitmap = aOutDevTest.setupDrawBitmap(vcl::PixelFormat::N24_BPP);
 472         exportImage(u"08-01_bitmap_test_24bpp.png"_ustr, aBitmap);
 473         auto eResult = vcl::test::OutputDeviceTestBitmap::checkTransformedBitmap(aBitmap);
 474         if (SHOULD_ASSERT)
 475             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 476     }
 477
 478     void testDrawTransformedBitmap24bpp()
 479     {
 480         if (getDefaultDeviceBitCount() < 24)
 481             return;
 482         vcl::test::OutputDeviceTestBitmap aOutDevTest;
 483         Bitmap aBitmap = aOutDevTest.setupDrawTransformedBitmap(vcl::PixelFormat::N24_BPP);
 484         auto eResult = vcl::test::OutputDeviceTestBitmap::checkTransformedBitmap(aBitmap);
 485         exportImage(u"08-02_transformed_bitmap_test_24bpp.png"_ustr, aBitmap);
 486         if (SHOULD_ASSERT)
 487             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 488     }
 489
 490     void testComplexDrawTransformedBitmap24bpp()
 491     {
 492         if (getDefaultDeviceBitCount() < 24)
 493             return;
 494         vcl::test::OutputDeviceTestBitmap aOutDevTest;
 495         Bitmap aBitmap = aOutDevTest.setupComplexDrawTransformedBitmap(vcl::PixelFormat::N24_BPP);
 496         auto eResult = vcl::test::OutputDeviceTestBitmap::checkComplexTransformedBitmap(aBitmap);
 497         exportImage(u"08-03_transformed_bitmap_test_24bpp.png"_ustr, aBitmap);
 498         if (SHOULD_ASSERT)
 499             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 500     }
 501
 502     void testDrawBitmapExWithAlpha24bpp()
 503     {
 504         if (getDefaultDeviceBitCount() < 24)
 505             return;
 506         vcl::test::OutputDeviceTestBitmap aOutDevTest;
 507         Bitmap aBitmap = aOutDevTest.setupDrawBitmapExWithAlpha(vcl::PixelFormat::N24_BPP);
 508         auto eResult = vcl::test::OutputDeviceTestBitmap::checkBitmapExWithAlpha(aBitmap);
 509         exportImage(u"08-04_bitmapex_with_alpha_test_24bpp.png"_ustr, aBitmap);
 510         if (SHOULD_ASSERT)
 511             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 512     }
 513
 514     void testDrawMask24bpp()
 515     {
 516         if (getDefaultDeviceBitCount() < 24)
 517             return;
 518         vcl::test::OutputDeviceTestBitmap aOutDevTest;
 519         Bitmap aBitmap = aOutDevTest.setupDrawMask(vcl::PixelFormat::N24_BPP);
 520         auto eResult = vcl::test::OutputDeviceTestBitmap::checkMask(aBitmap);
 521         exportImage(u"08-05_mask_test_24bpp.png"_ustr, aBitmap);
 522         if (SHOULD_ASSERT)
 523             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 524     }
 525
 526     void testDrawBlend24bpp()
 527     {
 528         if (getDefaultDeviceBitCount() < 24)
 529             return;
 530         vcl::test::OutputDeviceTestBitmap aOutDevTest;
 531         BitmapEx aBitmapEx = aOutDevTest.setupDrawBlend(vcl::PixelFormat::N24_BPP);
 532         auto eResult = vcl::test::OutputDeviceTestBitmap::checkBlend(aBitmapEx);
 533         exportImage(u"08-06_blend_test_24bpp.png"_ustr, aBitmapEx);
 534         if (SHOULD_ASSERT)
 535             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 536     }
 537
 538     void testDrawBitmap32bpp()
 539     {
 540         if (getDefaultDeviceBitCount() < 24)
 541             return;
 542         vcl::test::OutputDeviceTestBitmap aOutDevTest;
 543         Bitmap aBitmap = aOutDevTest.setupDrawBitmap(vcl::PixelFormat::N32_BPP);
 544         exportImage(u"09-01_bitmap_test_32bpp.png"_ustr, aBitmap);
 545         auto eResult = vcl::test::OutputDeviceTestBitmap::checkTransformedBitmap(aBitmap);
 546         if (SHOULD_ASSERT && is32bppSupported())
 547             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 548     }
 549
 550     void testDrawTransformedBitmap32bpp()
 551     {
 552         if (getDefaultDeviceBitCount() < 24)
 553             return;
 554         vcl::test::OutputDeviceTestBitmap aOutDevTest;
 555         Bitmap aBitmap = aOutDevTest.setupDrawTransformedBitmap(vcl::PixelFormat::N32_BPP);
 556         auto eResult = vcl::test::OutputDeviceTestBitmap::checkTransformedBitmap(aBitmap);
 557         exportImage(u"09-02_transformed_bitmap_test_32bpp.png"_ustr, aBitmap);
 558         if (SHOULD_ASSERT && is32bppSupported())
 559             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 560     }
 561
 562     void testDrawBitmapExWithAlpha32bpp()
 563     {
 564         if (getDefaultDeviceBitCount() < 24)
 565             return;
 566         vcl::test::OutputDeviceTestBitmap aOutDevTest;
 567         Bitmap aBitmap = aOutDevTest.setupDrawBitmapExWithAlpha(vcl::PixelFormat::N32_BPP);
 568         auto eResult = vcl::test::OutputDeviceTestBitmap::checkBitmapExWithAlpha(aBitmap);
 569         exportImage(u"09-03_bitmapex_with_alpha_test_32bpp.png"_ustr, aBitmap);
 570         if (SHOULD_ASSERT && is32bppSupported())
 571             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 572     }
 573
 574     void testDrawMask32bpp()
 575     {
 576         if (getDefaultDeviceBitCount() < 24)
 577             return;
 578         vcl::test::OutputDeviceTestBitmap aOutDevTest;
 579         Bitmap aBitmap = aOutDevTest.setupDrawMask(vcl::PixelFormat::N32_BPP);
 580         auto eResult = vcl::test::OutputDeviceTestBitmap::checkMask(aBitmap);
 581         exportImage(u"09-04_mask_test_32bpp.png"_ustr, aBitmap);
 582         if (SHOULD_ASSERT && is32bppSupported())
 583             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 584     }
 585
 586     void testDrawBlend32bpp()
 587     {
 588         if (getDefaultDeviceBitCount() < 24)
 589             return;
 590         vcl::test::OutputDeviceTestBitmap aOutDevTest;
 591         BitmapEx aBitmapEx = aOutDevTest.setupDrawBlend(vcl::PixelFormat::N32_BPP);
 592         auto eResult = vcl::test::OutputDeviceTestBitmap::checkBlend(aBitmapEx);
 593         exportImage(u"09-05_blend_test_32bpp.png"_ustr, aBitmapEx);
 594         if (SHOULD_ASSERT && is32bppSupported())
 595             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 596     }
 597
 598     void testDrawBitmap8bppGreyScale()
 599     {
 600         if (getDefaultDeviceBitCount() < 24)
 601             return;
 602         vcl::test::OutputDeviceTestBitmap aOutDevTest;
 603         Bitmap aBitmap = aOutDevTest.setupDrawBitmap(vcl::PixelFormat::N8_BPP, true);
 604         exportImage(u"010-01_bitmap_test_8bpp_greyscale.png"_ustr, aBitmap);
 605         auto eResult
 606             = vcl::test::OutputDeviceTestBitmap::checkTransformedBitmap8bppGreyScale(aBitmap);
 607         if (SHOULD_ASSERT)
 608             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 609     }
 610
 611     void testDrawTransformedBitmap8bppGreyScale()
 612     {
 613         if (getDefaultDeviceBitCount() < 24)
 614             return;
 615         vcl::test::OutputDeviceTestBitmap aOutDevTest;
 616         Bitmap aBitmap = aOutDevTest.setupDrawTransformedBitmap(vcl::PixelFormat::N8_BPP, true);
 617         auto eResult
 618             = vcl::test::OutputDeviceTestBitmap::checkTransformedBitmap8bppGreyScale(aBitmap);
 619         exportImage(u"010-02_transformed_bitmap_test_8bpp_greyscale.png"_ustr, aBitmap);
 620         if (SHOULD_ASSERT)
 621             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 622     }
 623
 624     void testDrawXor()
 625     {
 626         if (getDefaultDeviceBitCount() < 24)
 627             return;
 628         vcl::test::OutputDeviceTestAnotherOutDev aOutDevTest;
 629         Bitmap aBitmap = aOutDevTest.setupXOR();
 630         auto eResult = vcl::test::OutputDeviceTestAnotherOutDev::checkXOR(aBitmap);
 631         exportImage(u"08-06_xor_test.png"_ustr, aBitmap);
 632         if (SHOULD_ASSERT)
 633             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 634     }
 635
 636     void testDrawTransformedBitmapExAlpha()
 637     {
 638         if (getDefaultDeviceBitCount() < 24)
 639             return;
 640         ScopedVclPtrInstance<VirtualDevice> device;
 641 #ifdef MACOSX
 642         // TODO: This unit test is not executed for macOS unless bitmap scaling is implemented
 643         if (getRenderBackendName(device) == "aqua")
 644             return;
 645 #endif
 646         device->SetOutputSizePixel(Size(16, 16));
 647         device->SetBackground(Wallpaper(COL_WHITE));
 648         device->Erase();
 649         Bitmap aBitmap(Size(16, 16), vcl::PixelFormat::N24_BPP);
 650         {
 651             // Fill the top left quarter with black.
 652             BitmapScopedWriteAccess pWriteAccess(aBitmap);
 653             pWriteAccess->Erase(COL_WHITE);
 654             for (int i = 0; i < 8; ++i)
 655                 for (int j = 0; j < 8; ++j)
 656                     pWriteAccess->SetPixel(j, i, COL_BLACK);
 657         }
 658         BitmapEx aBitmapEx(aBitmap);
 659         basegfx::B2DHomMatrix aMatrix;
 660         // Draw with no transformation, only alpha change.
 661         aMatrix.scale(16, 16);
 662         device->DrawTransformedBitmapEx(aMatrix, aBitmapEx, 0.5);
 663         BitmapEx result = device->GetBitmapEx(Point(0, 0), Size(16, 16));
 664         CPPUNIT_ASSERT_EQUAL(COL_GRAY, result.GetPixelColor(0, 0));
 665         CPPUNIT_ASSERT_EQUAL(COL_WHITE, result.GetPixelColor(15, 15));
 666         // Draw rotated and move to the bottom-left corner.
 667         device->Erase();
 668         aMatrix.identity();
 669         aMatrix.scale(16, 16);
 670         aMatrix.rotate(M_PI / 2);
 671         aMatrix.translate(8, 8);
 672         device->DrawTransformedBitmapEx(aMatrix, aBitmapEx, 0.5);
 673         result = device->GetBitmap(Point(0, 0), Size(16, 16));
 674         CPPUNIT_ASSERT_EQUAL(COL_WHITE, result.GetPixelColor(0, 0));
 675         CPPUNIT_ASSERT_EQUAL(COL_GRAY, result.GetPixelColor(0, 15));
 676     }
 677
 678     void testClipRectangle()
 679     {
 680         if (getDefaultDeviceBitCount() < 24)
 681             return;
 682         vcl::test::OutputDeviceTestClip aOutDevTest;
 683         Bitmap aBitmap = aOutDevTest.setupClipRectangle();
 684         auto eResult = vcl::test::OutputDeviceTestClip::checkClip(aBitmap);
 685         exportImage(u"09-01_clip_rectangle_test.png"_ustr, aBitmap);
 686         if (SHOULD_ASSERT)
 687             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 688     }
 689
 690     void testClipPolygon()
 691     {
 692         if (getDefaultDeviceBitCount() < 24)
 693             return;
 694         vcl::test::OutputDeviceTestClip aOutDevTest;
 695         Bitmap aBitmap = aOutDevTest.setupClipPolygon();
 696         auto eResult = vcl::test::OutputDeviceTestClip::checkClip(aBitmap);
 697         exportImage(u"09-02_clip_polygon_test.png"_ustr, aBitmap);
 698         if (SHOULD_ASSERT)
 699             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 700     }
 701
 702     void testClipPolyPolygon()
 703     {
 704         if (getDefaultDeviceBitCount() < 24)
 705             return;
 706         vcl::test::OutputDeviceTestClip aOutDevTest;
 707         Bitmap aBitmap = aOutDevTest.setupClipPolyPolygon();
 708         auto eResult = vcl::test::OutputDeviceTestClip::checkClip(aBitmap);
 709         exportImage(u"09-03_clip_polypolygon_test.png"_ustr, aBitmap);
 710         if (SHOULD_ASSERT)
 711             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 712     }
 713
 714     void testClipB2DPolyPolygon()
 715     {
 716         if (getDefaultDeviceBitCount() < 24)
 717             return;
 718         vcl::test::OutputDeviceTestClip aOutDevTest;
 719         Bitmap aBitmap = aOutDevTest.setupClipB2DPolyPolygon();
 720         auto eResult = vcl::test::OutputDeviceTestClip::checkClip(aBitmap);
 721         exportImage(u"09-04_clip_b2dpolypolygon_test.png"_ustr, aBitmap);
 722         if (SHOULD_ASSERT)
 723             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 724     }
 725
 726     void testDrawOutDev()
 727     {
 728         if (getDefaultDeviceBitCount() < 24)
 729             return;
 730         vcl::test::OutputDeviceTestAnotherOutDev aOutDevTest;
 731         Bitmap aBitmap = aOutDevTest.setupDrawOutDev();
 732         auto eResult = vcl::test::OutputDeviceTestAnotherOutDev::checkDrawOutDev(aBitmap);
 733         exportImage(u"10-01_draw_out_dev_test.png"_ustr, aBitmap);
 734         if (SHOULD_ASSERT)
 735             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 736     }
 737
 738     void testDrawOutDevScaledClipped()
 739     {
 740         if (getDefaultDeviceBitCount() < 24)
 741             return;
 742         vcl::test::OutputDeviceTestAnotherOutDev aOutDevTest;
 743         Bitmap aBitmap = aOutDevTest.setupDrawOutDevScaledClipped();
 744         auto eResult
 745             = vcl::test::OutputDeviceTestAnotherOutDev::checkDrawOutDevScaledClipped(aBitmap);
 746         exportImage(u"10-02_draw_out_dev_scaled_clipped_test.png"_ustr, aBitmap);
 747         if (SHOULD_ASSERT)
 748             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 749     }
 750
 751     void testDrawOutDevSelf()
 752     {
 753         if (getDefaultDeviceBitCount() < 24)
 754             return;
 755         vcl::test::OutputDeviceTestAnotherOutDev aOutDevTest;
 756         Bitmap aBitmap = aOutDevTest.setupDrawOutDevSelf();
 757         auto eResult = vcl::test::OutputDeviceTestAnotherOutDev::checkDrawOutDevSelf(aBitmap);
 758         exportImage(u"10-03_draw_out_dev_self_test.png"_ustr, aBitmap);
 759         if (SHOULD_ASSERT)
 760             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 761     }
 762
 763     void testDashedLine()
 764     {
 765         if (getDefaultDeviceBitCount() < 24)
 766             return;
 767         vcl::test::OutputDeviceTestLine aOutDevTest;
 768         Bitmap aBitmap = aOutDevTest.setupDashedLine();
 769         auto eResult = vcl::test::OutputDeviceTestLine::checkDashedLine(aBitmap);
 770         exportImage(u"11-01_dashed_line_test.png"_ustr, aBitmap);
 771         if (SHOULD_ASSERT)
 772             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 773     }
 774
 775     void testErase()
 776     {
 777         if (getDefaultDeviceBitCount() < 24)
 778             return;
 779         {
 780             // Create normal virtual device (no alpha).
 781             ScopedVclPtr<VirtualDevice> device
 782                 = VclPtr<VirtualDevice>::Create(DeviceFormat::WITHOUT_ALPHA);
 783             device->SetOutputSizePixel(Size(10, 10));
 784             // Erase with white, check it's white.
 785             device->SetBackground(Wallpaper(COL_WHITE));
 786             device->Erase();
 787             exportDevice(u"12-01_erase.png"_ustr, device);
 788             CPPUNIT_ASSERT_EQUAL(COL_WHITE, device->GetPixel(Point(0, 0)));
 789             CPPUNIT_ASSERT_EQUAL(COL_WHITE, device->GetPixel(Point(9, 9)));
 790             CPPUNIT_ASSERT_EQUAL(COL_WHITE, device->GetPixel(Point(5, 5)));
 791             // Erase with black, check it's black.
 792             device->SetBackground(Wallpaper(COL_BLACK));
 793             device->Erase();
 794             exportDevice(u"12-02_erase.png"_ustr, device);
 795             CPPUNIT_ASSERT_EQUAL(COL_BLACK, device->GetPixel(Point(0, 0)));
 796             CPPUNIT_ASSERT_EQUAL(COL_BLACK, device->GetPixel(Point(9, 9)));
 797             CPPUNIT_ASSERT_EQUAL(COL_BLACK, device->GetPixel(Point(5, 5)));
 798             // Erase with cyan, check it's cyan.
 799             device->SetBackground(Wallpaper(COL_CYAN));
 800             device->Erase();
 801             exportDevice(u"12-03_erase.png"_ustr, device);
 802             CPPUNIT_ASSERT_EQUAL(COL_CYAN, device->GetPixel(Point(0, 0)));
 803             CPPUNIT_ASSERT_EQUAL(COL_CYAN, device->GetPixel(Point(9, 9)));
 804             CPPUNIT_ASSERT_EQUAL(COL_CYAN, device->GetPixel(Point(5, 5)));
 805         }
 806         {
 807             // Create virtual device with alpha.
 808             ScopedVclPtr<VirtualDevice> device
 809                 = VclPtr<VirtualDevice>::Create(DeviceFormat::WITH_ALPHA);
 810             device->SetOutputSizePixel(Size(10, 10));
 811             // Erase with white, check it's white.
 812             device->SetBackground(Wallpaper(COL_WHITE));
 813             device->Erase();
 814             exportDevice(u"12-04_erase.png"_ustr, device);
 815             CPPUNIT_ASSERT_EQUAL(COL_WHITE, device->GetPixel(Point(0, 0)));
 816             CPPUNIT_ASSERT_EQUAL(COL_WHITE, device->GetPixel(Point(9, 9)));
 817             CPPUNIT_ASSERT_EQUAL(COL_WHITE, device->GetPixel(Point(5, 5)));
 818             // Erase with black, check it's black.
 819             device->SetBackground(Wallpaper(COL_BLACK));
 820             device->Erase();
 821             exportDevice(u"12-05_erase.png"_ustr, device);
 822             CPPUNIT_ASSERT_EQUAL(COL_BLACK, device->GetPixel(Point(0, 0)));
 823             CPPUNIT_ASSERT_EQUAL(COL_BLACK, device->GetPixel(Point(9, 9)));
 824             CPPUNIT_ASSERT_EQUAL(COL_BLACK, device->GetPixel(Point(5, 5)));
 825             // Erase with cyan, check it's cyan.
 826             device->SetBackground(Wallpaper(COL_CYAN));
 827             device->Erase();
 828             exportDevice(u"12-06_erase.png"_ustr, device);
 829             CPPUNIT_ASSERT_EQUAL(COL_CYAN, device->GetPixel(Point(0, 0)));
 830             CPPUNIT_ASSERT_EQUAL(COL_CYAN, device->GetPixel(Point(9, 9)));
 831             CPPUNIT_ASSERT_EQUAL(COL_CYAN, device->GetPixel(Point(5, 5)));
 832             // Erase with transparent, check it's transparent.
 833             device->SetBackground(Wallpaper(COL_TRANSPARENT));
 834             device->Erase();
 835             exportDevice(u"12-07_erase.png"_ustr, device);
 836             CPPUNIT_ASSERT_EQUAL(sal_uInt8(0), device->GetPixel(Point(0, 0)).GetAlpha());
 837             CPPUNIT_ASSERT_EQUAL(sal_uInt8(0), device->GetPixel(Point(9, 9)).GetAlpha());
 838             CPPUNIT_ASSERT_EQUAL(sal_uInt8(0), device->GetPixel(Point(5, 5)).GetAlpha());
 839         }
 840     }
 841
 842     void testLinearGradient()
 843     {
 844         if (getDefaultDeviceBitCount() < 24)
 845             return;
 846         vcl::test::OutputDeviceTestGradient aOutDevTest;
 847         Bitmap aBitmap = aOutDevTest.setupLinearGradient();
 848         auto eResult = vcl::test::OutputDeviceTestGradient::checkLinearGradient(aBitmap);
 849         exportImage(u"13-01_linear_gradient_test.png"_ustr, aBitmap);
 850         if (SHOULD_ASSERT)
 851             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 852     }
 853
 854     void testLinearGradientAngled()
 855     {
 856         if (getDefaultDeviceBitCount() < 24)
 857             return;
 858         vcl::test::OutputDeviceTestGradient aOutDevTest;
 859         Bitmap aBitmap = aOutDevTest.setupLinearGradientAngled();
 860         auto eResult = vcl::test::OutputDeviceTestGradient::checkLinearGradientAngled(aBitmap);
 861         exportImage(u"13-02_linear_gradient_angled_test.png"_ustr, aBitmap);
 862         if (SHOULD_ASSERT)
 863             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 864     }
 865
 866     void testLinearGradientBorder()
 867     {
 868         vcl::test::OutputDeviceTestGradient aOutDevTest;
 869         Bitmap aBitmap = aOutDevTest.setupLinearGradientBorder();
 870         auto eResult = vcl::test::OutputDeviceTestGradient::checkLinearGradientBorder(aBitmap);
 871         exportImage(u"13-03_linear_gradient_border_test.png"_ustr, aBitmap);
 872         if (SHOULD_ASSERT)
 873             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 874     }
 875
 876     void testLinearGradientIntensity()
 877     {
 878         if (getDefaultDeviceBitCount() < 24)
 879             return;
 880         vcl::test::OutputDeviceTestGradient aOutDevTest;
 881         Bitmap aBitmap = aOutDevTest.setupLinearGradientIntensity();
 882         auto eResult = vcl::test::OutputDeviceTestGradient::checkLinearGradientIntensity(aBitmap);
 883         exportImage(u"13-04_linear_gradient_intensity_test.png"_ustr, aBitmap);
 884         if (SHOULD_ASSERT)
 885             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 886     }
 887
 888     void testLinearGradientSteps()
 889     {
 890         if (getDefaultDeviceBitCount() < 24)
 891             return;
 892         vcl::test::OutputDeviceTestGradient aOutDevTest;
 893         Bitmap aBitmap = aOutDevTest.setupLinearGradientSteps();
 894         auto eResult = vcl::test::OutputDeviceTestGradient::checkLinearGradientSteps(aBitmap);
 895         exportImage(u"13-05_linear_gradient_steps_test.png"_ustr, aBitmap);
 896         if (SHOULD_ASSERT)
 897             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 898     }
 899
 900     void testAxialGradient()
 901     {
 902         if (getDefaultDeviceBitCount() < 24)
 903             return;
 904         vcl::test::OutputDeviceTestGradient aOutDevTest;
 905         Bitmap aBitmap = aOutDevTest.setupAxialGradient();
 906         auto eResult = vcl::test::OutputDeviceTestGradient::checkAxialGradient(aBitmap);
 907         exportImage(u"13-06_axial_gradient_test.png"_ustr, aBitmap);
 908         if (SHOULD_ASSERT)
 909             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 910     }
 911
 912     void testRadialGradient()
 913     {
 914         if (getDefaultDeviceBitCount() < 24)
 915             return;
 916         vcl::test::OutputDeviceTestGradient aOutDevTest;
 917         Bitmap aBitmap = aOutDevTest.setupRadialGradient();
 918         auto eResult = vcl::test::OutputDeviceTestGradient::checkRadialGradient(aBitmap);
 919         exportImage(u"13-07_radial_gradient_test.png"_ustr, aBitmap);
 920         if (SHOULD_ASSERT)
 921             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 922     }
 923
 924     void testRadialGradientOfs()
 925     {
 926         vcl::test::OutputDeviceTestGradient aOutDevTest;
 927         Bitmap aBitmap = aOutDevTest.setupRadialGradientOfs();
 928         auto eResult = vcl::test::OutputDeviceTestGradient::checkRadialGradientOfs(aBitmap);
 929         exportImage(u"13-08_radial_gradient_ofs_test.png"_ustr, aBitmap);
 930         if (SHOULD_ASSERT)
 931             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 932     }
 933
 934     void testLineJoinBevel()
 935     {
 936         vcl::test::OutputDeviceTestLine aOutDevTest;
 937         Bitmap aBitmap = aOutDevTest.setupLineJoinBevel();
 938         auto eResult = vcl::test::OutputDeviceTestLine::checkLineJoinBevel(aBitmap);
 939         exportImage(u"14-01_line_join_bevel_test.png"_ustr, aBitmap);
 940         if (SHOULD_ASSERT)
 941             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 942     }
 943
 944     void testLineJoinRound()
 945     {
 946         vcl::test::OutputDeviceTestLine aOutDevTest;
 947         Bitmap aBitmap = aOutDevTest.setupLineJoinRound();
 948         auto eResult = vcl::test::OutputDeviceTestLine::checkLineJoinRound(aBitmap);
 949         exportImage(u"14-02_line_join_round_test.png"_ustr, aBitmap);
 950         if (SHOULD_ASSERT)
 951             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 952     }
 953
 954     void testLineJoinMiter()
 955     {
 956         vcl::test::OutputDeviceTestLine aOutDevTest;
 957         Bitmap aBitmap = aOutDevTest.setupLineJoinMiter();
 958         auto eResult = vcl::test::OutputDeviceTestLine::checkLineJoinMiter(aBitmap);
 959         exportImage(u"14-03_line_join_miter_test.png"_ustr, aBitmap);
 960         if (SHOULD_ASSERT)
 961             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 962     }
 963
 964     void testLineJoinNone()
 965     {
 966         vcl::test::OutputDeviceTestLine aOutDevTest;
 967         Bitmap aBitmap = aOutDevTest.setupLineJoinNone();
 968         auto eResult = vcl::test::OutputDeviceTestLine::checkLineJoinNone(aBitmap);
 969         exportImage(u"14-04_line_join_none_test.png"_ustr, aBitmap);
 970         if (SHOULD_ASSERT)
 971             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 972     }
 973
 974     void testLineCapRound()
 975     {
 976         vcl::test::OutputDeviceTestLine aOutDevTest;
 977         Bitmap aBitmap = aOutDevTest.setupLineCapRound();
 978         auto eResult = vcl::test::OutputDeviceTestLine::checkLineCapRound(aBitmap);
 979         exportImage(u"14-05_line_cap_round_test.png"_ustr, aBitmap);
 980         if (SHOULD_ASSERT)
 981             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 982     }
 983
 984     void testLineCapSquare()
 985     {
 986         vcl::test::OutputDeviceTestLine aOutDevTest;
 987         Bitmap aBitmap = aOutDevTest.setupLineCapSquare();
 988         auto eResult = vcl::test::OutputDeviceTestLine::checkLineCapSquare(aBitmap);
 989         exportImage(u"14-06_line_cap_square_test.png"_ustr, aBitmap);
 990         if (SHOULD_ASSERT)
 991             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
 992     }
 993
 994     void testLineCapButt()
 995     {
 996         vcl::test::OutputDeviceTestLine aOutDevTest;
 997         Bitmap aBitmap = aOutDevTest.setupLineCapButt();
 998         auto eResult = vcl::test::OutputDeviceTestLine::checkLineCapButt(aBitmap);
 999         exportImage(u"14-07_line_cap_butt_test.png"_ustr, aBitmap);
1000         if (SHOULD_ASSERT)
1001             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
1002     }
1003
1004     void testDrawDropShapeWithPolyline()
1005     {
1006         vcl::test::OutputDeviceTestPolyLine aOutDevTest;
1007         Bitmap aBitmap = aOutDevTest.setupDropShape();
1008         auto eResult = vcl::test::OutputDeviceTestCommon::checkDropShape(aBitmap);
1009         exportImage(u"15-01_drop_shape_test-polyline.png"_ustr, aBitmap);
1010         if (SHOULD_ASSERT)
1011             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
1012     }
1013
1014     void testDrawDropShapeAAWithPolyline()
1015     {
1016         vcl::test::OutputDeviceTestPolyLine aOutDevTest;
1017         Bitmap aBitmap = aOutDevTest.setupAADropShape();
1018         auto eResult = vcl::test::OutputDeviceTestCommon::checkDropShape(aBitmap, true);
1019         exportImage(u"15-02_drop_shape_AA_test-polyline.png"_ustr, aBitmap);
1020         if (SHOULD_ASSERT)
1021             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
1022     }
1023
1024     void testDrawDropShapeWithPolygon()
1025     {
1026         vcl::test::OutputDeviceTestPolygon aOutDevTest;
1027         Bitmap aBitmap = aOutDevTest.setupDropShape();
1028         auto eResult = vcl::test::OutputDeviceTestCommon::checkDropShape(aBitmap);
1029         exportImage(u"16-01_drop_shape_test-polygon.png"_ustr, aBitmap);
1030         if (SHOULD_ASSERT)
1031             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
1032     }
1033
1034     void testDrawDropShapeAAWithPolygon()
1035     {
1036         vcl::test::OutputDeviceTestPolygon aOutDevTest;
1037         Bitmap aBitmap = aOutDevTest.setupAADropShape();
1038         auto eResult = vcl::test::OutputDeviceTestCommon::checkDropShape(aBitmap, true);
1039         exportImage(u"16-02_drop_shape_AA_test-polygon.png"_ustr, aBitmap);
1040         if (SHOULD_ASSERT)
1041             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
1042     }
1043
1044     void testDrawHaflEllipseWithPolyLine()
1045     {
1046         vcl::test::OutputDeviceTestPolyLine aOutDevTest;
1047         Bitmap aBitmap = aOutDevTest.setupHalfEllipse();
1048         auto eResult = vcl::test::OutputDeviceTestCommon::checkHalfEllipse(aBitmap);
1049         exportImage(u"17-01_half_ellipse_test-polyline.png"_ustr, aBitmap);
1050         if (SHOULD_ASSERT)
1051             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
1052     }
1053
1054     void testDrawHaflEllipseAAWithPolyLine()
1055     {
1056         vcl::test::OutputDeviceTestPolyLine aOutDevTest;
1057         Bitmap aBitmap = aOutDevTest.setupHalfEllipse(true);
1058         auto eResult = vcl::test::OutputDeviceTestCommon::checkHalfEllipse(aBitmap, true);
1059         exportImage(u"17-02_half_ellipse_AA_test-polyline.png"_ustr, aBitmap);
1060         if (SHOULD_ASSERT)
1061             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
1062     }
1063
1064     void testDrawHaflEllipseWithPolyLineB2D()
1065     {
1066         vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
1067         Bitmap aBitmap = aOutDevTest.setupHalfEllipse();
1068         auto eResult = vcl::test::OutputDeviceTestCommon::checkHalfEllipse(aBitmap);
1069         exportImage(u"17-03_half_ellipse_test-polylineb2d.png"_ustr, aBitmap);
1070         if (SHOULD_ASSERT)
1071             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
1072     }
1073
1074     void testDrawHaflEllipseAAWithPolyLineB2D()
1075     {
1076         vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
1077         Bitmap aBitmap = aOutDevTest.setupHalfEllipse(true);
1078         auto eResult = vcl::test::OutputDeviceTestCommon::checkHalfEllipse(aBitmap, true);
1079         exportImage(u"17-03_half_ellipse_AA_test-polylineb2d.png"_ustr, aBitmap);
1080         if (SHOULD_ASSERT)
1081             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
1082     }
1083
1084     void testDrawHaflEllipseWithPolygon()
1085     {
1086         vcl::test::OutputDeviceTestPolyLine aOutDevTest;
1087         Bitmap aBitmap = aOutDevTest.setupHalfEllipse();
1088         auto eResult = vcl::test::OutputDeviceTestCommon::checkHalfEllipse(aBitmap);
1089         exportImage(u"17-04_half_ellipse_test-polygon.png"_ustr, aBitmap);
1090         if (SHOULD_ASSERT)
1091             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
1092     }
1093
1094     void testDrawHaflEllipseAAWithPolygon()
1095     {
1096         vcl::test::OutputDeviceTestPolyLine aOutDevTest;
1097         Bitmap aBitmap = aOutDevTest.setupHalfEllipse(true);
1098         auto eResult = vcl::test::OutputDeviceTestCommon::checkHalfEllipse(aBitmap, true);
1099         exportImage(u"17-05_half_ellipse_AA_test-polygon.png"_ustr, aBitmap);
1100         if (SHOULD_ASSERT)
1101             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
1102     }
1103
1104     void testClosedBezierWithPolyline()
1105     {
1106         vcl::test::OutputDeviceTestPolyLine aOutDevTest;
1107         Bitmap aBitmap = aOutDevTest.setupClosedBezier();
1108         auto eResult = vcl::test::OutputDeviceTestCommon::checkClosedBezier(aBitmap);
1109         exportImage(u"18-01_closed_bezier-polyline.png"_ustr, aBitmap);
1110         if (SHOULD_ASSERT)
1111             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
1112     }
1113
1114     void testClosedBezierWithPolygon()
1115     {
1116         vcl::test::OutputDeviceTestPolygon aOutDevTest;
1117         Bitmap aBitmap = aOutDevTest.setupClosedBezier();
1118         auto eResult = vcl::test::OutputDeviceTestCommon::checkClosedBezier(aBitmap);
1119         exportImage(u"18-02_closed_bezier-polygon.png"_ustr, aBitmap);
1120         if (SHOULD_ASSERT)
1121             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
1122     }
1123
1124     void testFilledAsymmetricalDropShape()
1125     {
1126         vcl::test::OutputDeviceTestPolygon aOutDevTest;
1127         Bitmap aBitmap = aOutDevTest.setupFilledAsymmetricalDropShape();
1128         vcl::test::TestResult eResult
1129             = vcl::test::OutputDeviceTestLine::checkFilledAsymmetricalDropShape(aBitmap);
1130         exportImage(u"19-01_filled_drop_shape-polygon.png"_ustr, aBitmap);
1131         if (SHOULD_ASSERT)
1132             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
1133     }
1134
1135     // Test SalGraphics::blendBitmap() and blendAlphaBitmap() calls.
1136     void testDrawBlendExtended()
1137     {
1138         if (getDefaultDeviceBitCount() < 24)
1139             return;
1140         // Create virtual device with alpha.
1141         ScopedVclPtr<VirtualDevice> device
1142             = VclPtr<VirtualDevice>::Create(DeviceFormat::WITH_ALPHA);
1143 #ifdef MACOSX
1144         // TODO: This unit test is not executed for macOS unless bitmap scaling is implemented
1145         if (getRenderBackendName(device) == "aqua")
1146             return;
1147 #endif
1148         device->SetOutputSizePixel(Size(10, 10));
1149         device->SetBackground(Wallpaper(COL_WHITE));
1150         device->Erase();
1151         Bitmap bitmap(Size(5, 5), vcl::PixelFormat::N24_BPP);
1152         bitmap.Erase(COL_BLUE);
1153         // No alpha, this will actually call SalGraphics::DrawBitmap(), but still check
1154         // the alpha of the device is handled correctly.
1155         device->DrawBitmapEx(Point(2, 2), BitmapEx(bitmap));
1156         exportDevice(u"blend_extended_01.png"_ustr, device);
1157         CPPUNIT_ASSERT_EQUAL(COL_BLUE, device->GetPixel(Point(2, 2)));
1158         CPPUNIT_ASSERT_EQUAL(COL_BLUE, device->GetPixel(Point(6, 6)));
1159         // Check pixels outside of the bitmap aren't affected.
1160         CPPUNIT_ASSERT_EQUAL(COL_WHITE, device->GetPixel(Point(1, 1)));
1161         CPPUNIT_ASSERT_EQUAL(COL_WHITE, device->GetPixel(Point(7, 7)));
1162
1163         device->Erase();
1164         AlphaMask alpha(Size(5, 5));
1165         alpha.Erase(0); // opaque
1166         device->DrawBitmapEx(Point(2, 2), BitmapEx(bitmap, alpha));
1167         exportDevice(u"blend_extended_02.png"_ustr, device);
1168         CPPUNIT_ASSERT_EQUAL(COL_BLUE, device->GetPixel(Point(2, 2)));
1169         CPPUNIT_ASSERT_EQUAL(COL_BLUE, device->GetPixel(Point(6, 6)));
1170
1171         device->Erase();
1172         alpha.Erase(255); // transparent
1173         device->DrawBitmapEx(Point(2, 2), BitmapEx(bitmap, alpha));
1174         exportDevice(u"blend_extended_03.png"_ustr, device);
1175         CPPUNIT_ASSERT_EQUAL(COL_WHITE, device->GetPixel(Point(2, 2)));
1176         CPPUNIT_ASSERT_EQUAL(COL_WHITE, device->GetPixel(Point(6, 6)));
1177
1178         // Skia optimizes bitmaps that have just been Erase()-ed, so explicitly
1179         // set some pixels in the alpha to avoid this and have an actual bitmap
1180         // as the alpha mask.
1181         device->Erase();
1182         alpha.Erase(255); // transparent
1183         BitmapScopedWriteAccess alphaWrite(alpha);
1184         alphaWrite->SetPixelIndex(0, 0, 255); // opaque
1185         alphaWrite.reset();
1186         device->DrawBitmapEx(Point(2, 2), BitmapEx(bitmap, alpha));
1187         exportDevice(u"blend_extended_04.png"_ustr, device);
1188         CPPUNIT_ASSERT_EQUAL(COL_BLUE, device->GetPixel(Point(2, 2)));
1189         CPPUNIT_ASSERT_EQUAL(COL_WHITE, device->GetPixel(Point(6, 6)));
1190     }
1191
1192     void testDrawAlphaBitmapMirrored()
1193     {
1194         if (getDefaultDeviceBitCount() < 24)
1195             return;
1196         // Normal virtual device.
1197         ScopedVclPtr<VirtualDevice> device
1198             = VclPtr<VirtualDevice>::Create(DeviceFormat::WITHOUT_ALPHA);
1199 #ifdef MACOSX
1200         // TODO: This unit test is not executed for macOS unless bitmap scaling is implemented
1201         if (getRenderBackendName(device) == "aqua")
1202             return;
1203 #endif
1204         // Virtual device with alpha.
1205         ScopedVclPtr<VirtualDevice> alphaDevice
1206             = VclPtr<VirtualDevice>::Create(DeviceFormat::WITH_ALPHA);
1207         device->SetOutputSizePixel(Size(20, 20));
1208         device->SetBackground(Wallpaper(COL_BLACK));
1209         device->Erase();
1210         alphaDevice->SetOutputSizePixel(Size(20, 20));
1211         alphaDevice->SetBackground(Wallpaper(COL_BLACK));
1212         alphaDevice->Erase();
1213         Bitmap bitmap(Size(4, 4), vcl::PixelFormat::N24_BPP);
1214         AlphaMask alpha(Size(4, 4));
1215         bitmap.Erase(COL_LIGHTBLUE);
1216         {
1217             BitmapScopedWriteAccess writeAccess(bitmap);
1218             writeAccess->SetPixel(3, 3, COL_LIGHTRED);
1219         }
1220         // alpha 127 will make COL_LIGHTRED -> COL_RED and the same for blue
1221         alpha.Erase(127);
1222         // Normal device.
1223         device->DrawBitmapEx(Point(5, 5), Size(-4, -4), BitmapEx(bitmap));
1224         device->DrawBitmapEx(Point(15, 15), Size(4, 4), BitmapEx(bitmap));
1225         exportDevice(u"draw_alpha_bitmap_mirrored_01.png"_ustr, device);
1226         CPPUNIT_ASSERT_EQUAL(COL_LIGHTRED, device->GetPixel(Point(18, 18)));
1227         CPPUNIT_ASSERT_EQUAL(COL_LIGHTBLUE, device->GetPixel(Point(17, 18)));
1228         CPPUNIT_ASSERT_EQUAL(COL_LIGHTRED, device->GetPixel(Point(2, 2)));
1229         CPPUNIT_ASSERT_EQUAL(COL_LIGHTBLUE, device->GetPixel(Point(3, 2)));
1230         device->Erase();
1231         device->DrawBitmapEx(Point(5, 5), Size(-4, -4), BitmapEx(bitmap, alpha));
1232         device->DrawBitmapEx(Point(15, 15), Size(4, 4), BitmapEx(bitmap, alpha));
1233         exportDevice(u"draw_alpha_bitmap_mirrored_02.png"_ustr, device);
1234         CPPUNIT_ASSERT_EQUAL(COL_RED, device->GetPixel(Point(18, 18)));
1235         CPPUNIT_ASSERT_EQUAL(COL_BLUE, device->GetPixel(Point(17, 18)));
1236         CPPUNIT_ASSERT_EQUAL(COL_RED, device->GetPixel(Point(2, 2)));
1237         CPPUNIT_ASSERT_EQUAL(COL_BLUE, device->GetPixel(Point(3, 2)));
1238         device->Erase();
1239         // Now with alpha device.
1240         alphaDevice->DrawBitmapEx(Point(5, 5), Size(-4, -4), BitmapEx(bitmap));
1241         alphaDevice->DrawBitmapEx(Point(15, 15), Size(4, 4), BitmapEx(bitmap));
1242         exportDevice(u"draw_alpha_bitmap_mirrored_03.png"_ustr, alphaDevice);
1243         CPPUNIT_ASSERT_EQUAL(COL_LIGHTRED, alphaDevice->GetPixel(Point(18, 18)));
1244         CPPUNIT_ASSERT_EQUAL(COL_LIGHTBLUE, alphaDevice->GetPixel(Point(17, 18)));
1245         CPPUNIT_ASSERT_EQUAL(COL_LIGHTRED, alphaDevice->GetPixel(Point(2, 2)));
1246         CPPUNIT_ASSERT_EQUAL(COL_LIGHTBLUE, alphaDevice->GetPixel(Point(3, 2)));
1247         alphaDevice->Erase();
1248         alphaDevice->DrawBitmapEx(Point(5, 5), Size(-4, -4), BitmapEx(bitmap, alpha));
1249         alphaDevice->DrawBitmapEx(Point(15, 15), Size(4, 4), BitmapEx(bitmap, alpha));
1250         exportDevice(u"draw_alpha_bitmap_mirrored_04.png"_ustr, alphaDevice);
1251         CPPUNIT_ASSERT_EQUAL(COL_RED, alphaDevice->GetPixel(Point(18, 18)));
1252         CPPUNIT_ASSERT_EQUAL(COL_BLUE, alphaDevice->GetPixel(Point(17, 18)));
1253         CPPUNIT_ASSERT_EQUAL(COL_RED, alphaDevice->GetPixel(Point(2, 2)));
1254         CPPUNIT_ASSERT_EQUAL(COL_BLUE, alphaDevice->GetPixel(Point(3, 2)));
1255         alphaDevice->Erase();
1256     }
1257
1258     void testDrawingText()
1259     {
1260 #ifndef _WIN32
1261         vcl::test::OutputDeviceTestText aOutDevTest;
1262         Bitmap aBitmap = aOutDevTest.setupTextBitmap();
1263         auto eResult = vcl::test::OutputDeviceTestCommon::checkTextLocation(aBitmap);
1264         exportImage(u"17-01_test_text_Drawing.png"_ustr, aBitmap);
1265         if (SHOULD_ASSERT)
1266             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
1267 #endif
1268     }
1269
1270     void testEvenOddRuleInIntersectionRectangles()
1271     {
1272         vcl::test::OutputDeviceTestPolyPolygon aOutDevTest;
1273         Bitmap aBitmap = aOutDevTest.setupIntersectingRectangles();
1274         auto eResult
1275             = vcl::test::OutputDeviceTestCommon::checkEvenOddRuleInIntersectingRecs(aBitmap);
1276         exportImage(u"18-01_test_Even-Odd-rule_intersecting_Recs.png"_ustr, aBitmap);
1277         if (SHOULD_ASSERT)
1278             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
1279     }
1280
1281     void testDrawOpenPolygonWithPolyLine()
1282     {
1283         vcl::test::OutputDeviceTestPolyLine aOutDevTest;
1284         Bitmap aBitmap = aOutDevTest.setupOpenPolygon();
1285         auto eResult = vcl::test::OutputDeviceTestCommon::checkOpenPolygon(aBitmap);
1286         exportImage(u"19-01_open_polygon-polyline.png"_ustr, aBitmap);
1287         if (SHOULD_ASSERT)
1288             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
1289     }
1290
1291     void testDrawOpenPolygonWithPolyLineB2D()
1292     {
1293         vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
1294         Bitmap aBitmap = aOutDevTest.setupOpenPolygon();
1295         auto eResult = vcl::test::OutputDeviceTestCommon::checkOpenPolygon(aBitmap);
1296         exportImage(u"19-02_open_polygon-polyline_b2d.png"_ustr, aBitmap);
1297         if (SHOULD_ASSERT)
1298             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
1299     }
1300
1301     void testDrawOpenPolygonWithPolygon()
1302     {
1303         vcl::test::OutputDeviceTestPolygon aOutDevTest;
1304         Bitmap aBitmap = aOutDevTest.setupOpenPolygon();
1305         auto eResult = vcl::test::OutputDeviceTestCommon::checkOpenPolygon(aBitmap);
1306         exportImage(u"19-03_open_polygon-polygon.png"_ustr, aBitmap);
1307         if (SHOULD_ASSERT)
1308             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
1309     }
1310
1311     void testDrawOpenPolygonWithPolyPolygon()
1312     {
1313         vcl::test::OutputDeviceTestPolyPolygon aOutDevTest;
1314         Bitmap aBitmap = aOutDevTest.setupOpenPolygon();
1315         auto eResult = vcl::test::OutputDeviceTestCommon::checkOpenPolygon(aBitmap);
1316         exportImage(u"19-04_open_polygon-polypolygon.png"_ustr, aBitmap);
1317         if (SHOULD_ASSERT)
1318             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
1319     }
1320
1321     void testDrawOpenPolygonWithPolyPolygonB2D()
1322     {
1323         vcl::test::OutputDeviceTestPolyPolygonB2D aOutDevTest;
1324         Bitmap aBitmap = aOutDevTest.setupOpenPolygon();
1325         auto eResult = vcl::test::OutputDeviceTestCommon::checkOpenPolygon(aBitmap);
1326         exportImage(u"19-04_open_polygon-polypolygon_b2d.png"_ustr, aBitmap);
1327         if (SHOULD_ASSERT)
1328             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
1329     }
1330
1331     void testDrawOpenBezierWithPolyLine()
1332     {
1333         vcl::test::OutputDeviceTestPolyLine aOutDevTest;
1334         Bitmap aBitmap = aOutDevTest.setupOpenBezier();
1335         auto eResult = vcl::test::OutputDeviceTestCommon::checkOpenBezier(aBitmap);
1336         exportImage(u"19-01_open_bezier-polyline.png"_ustr, aBitmap);
1337         if (SHOULD_ASSERT)
1338             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
1339     }
1340
1341     void testDrawOpenBezierWithPolyLineB2D()
1342     {
1343         vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
1344         Bitmap aBitmap = aOutDevTest.setupOpenBezier();
1345         auto eResult = vcl::test::OutputDeviceTestCommon::checkOpenBezier(aBitmap);
1346         exportImage(u"19-01_open_bezier-polyline_b2d.png"_ustr, aBitmap);
1347         if (SHOULD_ASSERT)
1348             CPPUNIT_ASSERT(eResult != vcl::test::TestResult::Failed);
1349     }
1350
1351     void testTdf124848()
1352     {
1353         ScopedVclPtr<VirtualDevice> device
1354             = VclPtr<VirtualDevice>::Create(DeviceFormat::WITHOUT_ALPHA);
1355 #ifdef MACOSX
1356         // TODO: This unit test is not executed for macOS unless bitmap scaling is implemented
1357         if (getRenderBackendName(device) == "aqua")
1358             return;
1359 #endif
1360         device->SetOutputSizePixel(Size(100, 100));
1361         device->SetBackground(Wallpaper(COL_WHITE));
1362         device->Erase();
1363         device->SetAntialiasing(AntialiasingFlags::Enable);
1364         device->SetLineColor(COL_BLACK);
1365         basegfx::B2DHomMatrix matrix;
1366         // DrawPolyLine() would apply the whole matrix to the line width, making it negative
1367         // in case of a larger rotation.
1368         matrix.rotate(M_PI); //180 degrees
1369         matrix.translate(100, 100);
1370         CPPUNIT_ASSERT(device->DrawPolyLineDirect(matrix,
1371                                                   basegfx::B2DPolygon{ { 50, 50 }, { 50, 100 } },
1372                                                   100, 0, nullptr, basegfx::B2DLineJoin::Miter));
1373         exportDevice(u"tdf124848-1.png"_ustr, device);
1374         // 100px wide line should fill the entire width of the upper half
1375         CPPUNIT_ASSERT_EQUAL(COL_BLACK, device->GetPixel(Point(2, 2)));
1376
1377         // Also check hairline.
1378         device->Erase();
1379         CPPUNIT_ASSERT(device->DrawPolyLineDirect(matrix,
1380                                                   basegfx::B2DPolygon{ { 50, 50 }, { 50, 100 } }, 0,
1381                                                   0, nullptr, basegfx::B2DLineJoin::Miter));
1382         exportDevice(u"tdf124848-2.png"_ustr, device);
1383         // 1px wide
1384         CPPUNIT_ASSERT_EQUAL(COL_BLACK, device->GetPixel(Point(50, 20)));
1385         CPPUNIT_ASSERT_EQUAL(COL_WHITE, device->GetPixel(Point(49, 20)));
1386         CPPUNIT_ASSERT_EQUAL(COL_WHITE, device->GetPixel(Point(51, 20)));
1387     }
1388
1389     void testTdf136171()
1390     {
1391         if (getDefaultDeviceBitCount() < 24)
1392             return;
1393         // Create virtual device with alpha.
1394         ScopedVclPtr<VirtualDevice> device
1395             = VclPtr<VirtualDevice>::Create(DeviceFormat::WITH_ALPHA);
1396         device->SetOutputSizePixel(Size(10, 10));
1397         device->SetBackground(Wallpaper(COL_WHITE));
1398         device->Erase();
1399         Bitmap bitmap(Size(10, 10), vcl::PixelFormat::N24_BPP);
1400         bitmap.Erase(COL_BLUE);
1401         basegfx::B2DHomMatrix matrix;
1402         matrix.scale(bitmap.GetSizePixel().Width(),
1403                      bitmap.GetSizePixel().Height()); // draw as 10x10
1404         // Draw a blue bitmap to the device. The bug was that there was no alpha, but OutputDevice::DrawTransformBitmapExDirect()
1405         // supplied a fully opaque alpha done with Erase() on the alpha bitmap, and Skia backend didn't handle such alpha correctly.
1406         device->DrawTransformedBitmapEx(matrix, BitmapEx(bitmap));
1407         exportDevice(u"tdf136171.png"_ustr, device);
1408         // The whole virtual device content now should be blue.
1409         CPPUNIT_ASSERT_EQUAL(COL_BLUE, device->GetPixel(Point(0, 0)));
1410         CPPUNIT_ASSERT_EQUAL(COL_BLUE, device->GetPixel(Point(9, 0)));
1411         CPPUNIT_ASSERT_EQUAL(COL_BLUE, device->GetPixel(Point(0, 9)));
1412         CPPUNIT_ASSERT_EQUAL(COL_BLUE, device->GetPixel(Point(9, 9)));
1413         CPPUNIT_ASSERT_EQUAL(COL_BLUE, device->GetPixel(Point(4, 4)));
1414     }
1415
1416     void testTdf145811()
1417     {
1418         // VCL may call copyArea()/copyBits() of backends even with coordinates partially
1419         // outside of the device, so try various copying like that.
1420         ScopedVclPtr<VirtualDevice> device1
1421             = VclPtr<VirtualDevice>::Create(DeviceFormat::WITHOUT_ALPHA);
1422         device1->SetOutputSizePixel(Size(100, 100));
1423         device1->SetBackground(Wallpaper(COL_YELLOW));
1424         device1->Erase();
1425         device1->SetLineColor(COL_BLUE);
1426         device1->DrawPixel(Point(0, 0), COL_BLUE);
1427         device1->DrawPixel(Point(99, 99), COL_BLUE);
1428 #ifdef MACOSX
1429         // TODO: This unit test is not executed for macOS unless bitmap scaling is implemented
1430         if (getRenderBackendName(device1) == "aqua")
1431             return;
1432 #endif
1433
1434         // Plain 1:1 copy device1->device2.
1435         ScopedVclPtr<VirtualDevice> device2
1436             = VclPtr<VirtualDevice>::Create(DeviceFormat::WITHOUT_ALPHA);
1437         device2->SetOutputSizePixel(Size(100, 100));
1438         device2->DrawOutDev(Point(0, 0), Size(100, 100), Point(0, 0), Size(100, 100), *device1);
1439         exportDevice(u"tdf145811-1.png"_ustr, device2);
1440         CPPUNIT_ASSERT_EQUAL(COL_BLUE, device2->GetPixel(Point(0, 0)));
1441         CPPUNIT_ASSERT_EQUAL(COL_YELLOW, device2->GetPixel(Point(1, 1)));
1442         CPPUNIT_ASSERT_EQUAL(COL_YELLOW, device2->GetPixel(Point(98, 98)));
1443         CPPUNIT_ASSERT_EQUAL(COL_BLUE, device2->GetPixel(Point(99, 99)));
1444
1445         // For the rest call directly SalGraphics, because OutputDevice does range checking,
1446         // but other code may call copyArea()/copyBits() of SalGraphics directly without range checking.
1447         SalGraphics* graphics1 = device1->GetGraphics();
1448         SalGraphics* graphics2 = device2->GetGraphics();
1449
1450         device2->DrawOutDev(Point(0, 0), Size(100, 100), Point(0, 0), Size(100, 100), *device1);
1451         // Copy device1->device2 offset by 10,10.
1452         graphics2->CopyBits(SalTwoRect(0, 0, 100, 100, 10, 10, 100, 100), *graphics1, *device2,
1453                             *device1);
1454         exportDevice(u"tdf145811-2.png"_ustr, device2);
1455         CPPUNIT_ASSERT_EQUAL(COL_BLUE, device2->GetPixel(Point(0, 0))); // unmodified
1456         CPPUNIT_ASSERT_EQUAL(COL_YELLOW, device2->GetPixel(Point(9, 9)));
1457         CPPUNIT_ASSERT_EQUAL(COL_BLUE, device2->GetPixel(Point(10, 10)));
1458         CPPUNIT_ASSERT_EQUAL(COL_YELLOW, device2->GetPixel(Point(11, 11)));
1459         CPPUNIT_ASSERT_EQUAL(COL_YELLOW, device2->GetPixel(Point(99, 99)));
1460
1461         device2->DrawOutDev(Point(0, 0), Size(100, 100), Point(0, 0), Size(100, 100), *device1);
1462         // Copy area of device2 offset by 10,10.
1463         graphics2->CopyArea(10, 10, 0, 0, 100, 100, *device1);
1464         exportDevice(u"tdf145811-3.png"_ustr, device2);
1465         CPPUNIT_ASSERT_EQUAL(COL_BLUE, device2->GetPixel(Point(0, 0))); // unmodified
1466         CPPUNIT_ASSERT_EQUAL(COL_YELLOW, device2->GetPixel(Point(9, 9)));
1467         CPPUNIT_ASSERT_EQUAL(COL_BLUE, device2->GetPixel(Point(10, 10)));
1468         CPPUNIT_ASSERT_EQUAL(COL_YELLOW, device2->GetPixel(Point(11, 11)));
1469         CPPUNIT_ASSERT_EQUAL(COL_YELLOW, device2->GetPixel(Point(99, 99)));
1470
1471         device2->DrawOutDev(Point(0, 0), Size(100, 100), Point(0, 0), Size(100, 100), *device1);
1472         // Copy device1->device2 offset by -20,-20.
1473         graphics2->CopyBits(SalTwoRect(0, 0, 100, 100, -20, -20, 100, 100), *graphics1, *device2,
1474                             *device1);
1475         exportDevice(u"tdf145811-4.png"_ustr, device2);
1476         CPPUNIT_ASSERT_EQUAL(COL_YELLOW, device2->GetPixel(Point(0, 0)));
1477         CPPUNIT_ASSERT_EQUAL(COL_YELLOW, device2->GetPixel(Point(78, 78)));
1478         CPPUNIT_ASSERT_EQUAL(COL_BLUE, device2->GetPixel(Point(79, 79)));
1479         CPPUNIT_ASSERT_EQUAL(COL_YELLOW, device2->GetPixel(Point(80, 80)));
1480         CPPUNIT_ASSERT_EQUAL(COL_BLUE, device2->GetPixel(Point(99, 99))); // unmodified
1481
1482         device2->DrawOutDev(Point(0, 0), Size(100, 100), Point(0, 0), Size(100, 100), *device1);
1483         // Copy area of device2 offset by -20,-20.
1484         graphics2->CopyArea(-20, -20, 0, 0, 100, 100, *device1);
1485         exportDevice(u"tdf145811-5.png"_ustr, device2);
1486         CPPUNIT_ASSERT_EQUAL(COL_YELLOW, device2->GetPixel(Point(0, 0)));
1487         CPPUNIT_ASSERT_EQUAL(COL_YELLOW, device2->GetPixel(Point(78, 78)));
1488         CPPUNIT_ASSERT_EQUAL(COL_BLUE, device2->GetPixel(Point(79, 79)));
1489         CPPUNIT_ASSERT_EQUAL(COL_YELLOW, device2->GetPixel(Point(80, 80)));
1490         CPPUNIT_ASSERT_EQUAL(COL_BLUE, device2->GetPixel(Point(99, 99))); // unmodified
1491
1492         device2->DrawOutDev(Point(0, 0), Size(100, 100), Point(0, 0), Size(100, 100), *device1);
1493         // Copy device1->device2 offset by -10,-10 starting from -20,-20 at 150x150 size
1494         // (i.e. outside in all directions).
1495         graphics2->CopyBits(SalTwoRect(-20, -20, 150, 150, -30, -30, 150, 150), *graphics1,
1496                             *device2, *device1);
1497         exportDevice(u"tdf145811-6.png"_ustr, device2);
1498         CPPUNIT_ASSERT_EQUAL(COL_YELLOW, device2->GetPixel(Point(0, 0)));
1499         CPPUNIT_ASSERT_EQUAL(COL_YELLOW, device2->GetPixel(Point(88, 88)));
1500         CPPUNIT_ASSERT_EQUAL(COL_BLUE, device2->GetPixel(Point(89, 89)));
1501         // (90,90) and further originate from outside and may be garbage.
1502
1503         device2->DrawOutDev(Point(0, 0), Size(100, 100), Point(0, 0), Size(100, 100), *device1);
1504         // Copy area of device2 offset by -10,-10 starting from -20,-20 at 150x150 size
1505         // (i.e. outside in all directions).
1506         graphics2->CopyArea(-30, -30, -20, -20, 150, 150, *device1);
1507         exportDevice(u"tdf145811-7.png"_ustr, device2);
1508         CPPUNIT_ASSERT_EQUAL(COL_YELLOW, device2->GetPixel(Point(0, 0)));
1509         CPPUNIT_ASSERT_EQUAL(COL_YELLOW, device2->GetPixel(Point(88, 88)));
1510         CPPUNIT_ASSERT_EQUAL(COL_BLUE, device2->GetPixel(Point(89, 89)));
1511         // (90,90) and further originate from outside and may be garbage.
1512     }
1513
1514     CPPUNIT_TEST_SUITE(BackendTest);
1515     CPPUNIT_TEST(testDrawRectWithRectangle);
1516     CPPUNIT_TEST(testDrawRectWithPixel);
1517     CPPUNIT_TEST(testDrawRectWithLine);
1518     CPPUNIT_TEST(testDrawRectWithPolygon);
1519     CPPUNIT_TEST(testDrawRectWithPolyLine);
1520     CPPUNIT_TEST(testDrawRectWithPolyLineB2D);
1521     CPPUNIT_TEST(testDrawRectWithPolyPolygon);
1522     CPPUNIT_TEST(testDrawRectWithPolyPolygonB2D);
1523
1524     CPPUNIT_TEST(testDrawRectAAWithRectangle);
1525     CPPUNIT_TEST(testDrawRectAAWithPixel);
1526     CPPUNIT_TEST(testDrawRectAAWithLine);
1527     CPPUNIT_TEST(testDrawRectAAWithPolygon);
1528     CPPUNIT_TEST(testDrawRectAAWithPolyLine);
1529     CPPUNIT_TEST(testDrawRectAAWithPolyLineB2D);
1530     CPPUNIT_TEST(testDrawRectAAWithPolyPolygon);
1531     CPPUNIT_TEST(testDrawRectAAWithPolyPolygonB2D);
1532
1533     CPPUNIT_TEST(testDrawFilledRectWithRectangle);
1534     CPPUNIT_TEST(testDrawFilledRectWithPolygon);
1535     CPPUNIT_TEST(testDrawFilledRectWithPolyPolygon);
1536     CPPUNIT_TEST(testDrawFilledRectWithPolyPolygon2D);
1537
1538     CPPUNIT_TEST(testDrawDiamondWithPolygon);
1539     CPPUNIT_TEST(testDrawDiamondWithLine);
1540     CPPUNIT_TEST(testDrawDiamondWithPolyline);
1541     CPPUNIT_TEST(testDrawDiamondWithPolylineB2D);
1542
1543     CPPUNIT_TEST(testDrawInvertWithRectangle);
1544     CPPUNIT_TEST(testDrawInvertN50WithRectangle);
1545     CPPUNIT_TEST(testDrawInvertTrackFrameWithRectangle);
1546
1547     CPPUNIT_TEST(testDrawBezierWithPolylineB2D);
1548     CPPUNIT_TEST(testDrawBezierAAWithPolylineB2D);
1549
1550     CPPUNIT_TEST(testDrawDropShapeWithPolyline);
1551     CPPUNIT_TEST(testDrawDropShapeAAWithPolyline);
1552
1553     CPPUNIT_TEST(testDrawDropShapeWithPolygon);
1554     CPPUNIT_TEST(testDrawDropShapeAAWithPolygon);
1555
1556     CPPUNIT_TEST(testDrawHaflEllipseWithPolyLine);
1557     CPPUNIT_TEST(testDrawHaflEllipseAAWithPolyLine);
1558     CPPUNIT_TEST(testDrawHaflEllipseWithPolyLineB2D);
1559     CPPUNIT_TEST(testDrawHaflEllipseAAWithPolyLineB2D);
1560     CPPUNIT_TEST(testDrawHaflEllipseWithPolygon);
1561     CPPUNIT_TEST(testDrawHaflEllipseAAWithPolygon);
1562
1563     CPPUNIT_TEST(testClosedBezierWithPolyline);
1564     CPPUNIT_TEST(testClosedBezierWithPolygon);
1565
1566     CPPUNIT_TEST(testFilledAsymmetricalDropShape);
1567
1568     CPPUNIT_TEST(testDrawBitmap24bpp);
1569     CPPUNIT_TEST(testDrawTransformedBitmap24bpp);
1570     CPPUNIT_TEST(testComplexDrawTransformedBitmap24bpp);
1571     CPPUNIT_TEST(testDrawBitmapExWithAlpha24bpp);
1572     CPPUNIT_TEST(testDrawMask24bpp);
1573     CPPUNIT_TEST(testDrawBlend24bpp);
1574
1575     CPPUNIT_TEST(testDrawXor);
1576
1577     CPPUNIT_TEST(testDrawBitmap32bpp);
1578     CPPUNIT_TEST(testDrawTransformedBitmap32bpp);
1579     CPPUNIT_TEST(testDrawBitmapExWithAlpha32bpp);
1580     CPPUNIT_TEST(testDrawMask32bpp);
1581     CPPUNIT_TEST(testDrawBlend32bpp);
1582
1583     CPPUNIT_TEST(testDrawTransformedBitmap8bppGreyScale);
1584     CPPUNIT_TEST(testDrawBitmap8bppGreyScale);
1585
1586     CPPUNIT_TEST(testDrawTransformedBitmapExAlpha);
1587
1588     CPPUNIT_TEST(testClipRectangle);
1589     CPPUNIT_TEST(testClipPolygon);
1590     CPPUNIT_TEST(testClipPolyPolygon);
1591     CPPUNIT_TEST(testClipB2DPolyPolygon);
1592
1593     CPPUNIT_TEST(testDrawOutDev);
1594     CPPUNIT_TEST(testDrawOutDevScaledClipped);
1595     CPPUNIT_TEST(testDrawOutDevSelf);
1596
1597     CPPUNIT_TEST(testDashedLine);
1598
1599     CPPUNIT_TEST(testErase);
1600
1601     CPPUNIT_TEST(testLinearGradient);
1602     CPPUNIT_TEST(testLinearGradientAngled);
1603     CPPUNIT_TEST(testLinearGradientBorder);
1604     CPPUNIT_TEST(testLinearGradientIntensity);
1605     CPPUNIT_TEST(testLinearGradientSteps);
1606     CPPUNIT_TEST(testAxialGradient);
1607     CPPUNIT_TEST(testRadialGradient);
1608     CPPUNIT_TEST(testRadialGradientOfs);
1609
1610     CPPUNIT_TEST(testLineCapRound);
1611     CPPUNIT_TEST(testLineCapSquare);
1612     CPPUNIT_TEST(testLineCapButt);
1613     CPPUNIT_TEST(testLineJoinBevel);
1614     CPPUNIT_TEST(testLineJoinRound);
1615     CPPUNIT_TEST(testLineJoinMiter);
1616     CPPUNIT_TEST(testLineJoinNone);
1617
1618     CPPUNIT_TEST(testDrawBlendExtended);
1619     CPPUNIT_TEST(testDrawAlphaBitmapMirrored);
1620
1621     CPPUNIT_TEST(testDrawingText);
1622     CPPUNIT_TEST(testEvenOddRuleInIntersectionRectangles);
1623
1624     CPPUNIT_TEST(testDrawOpenPolygonWithPolyLine);
1625     CPPUNIT_TEST(testDrawOpenPolygonWithPolyLineB2D);
1626     CPPUNIT_TEST(testDrawOpenPolygonWithPolygon);
1627     CPPUNIT_TEST(testDrawOpenPolygonWithPolyPolygon);
1628     CPPUNIT_TEST(testDrawOpenPolygonWithPolyPolygonB2D);
1629
1630     CPPUNIT_TEST(testDrawOpenBezierWithPolyLine);
1631     CPPUNIT_TEST(testDrawOpenBezierWithPolyLineB2D);
1632
1633     CPPUNIT_TEST(testTdf124848);
1634     CPPUNIT_TEST(testTdf136171);
1635     CPPUNIT_TEST(testTdf145811);
1636
1637     CPPUNIT_TEST_SUITE_END();
1638 };
1639
1640 CPPUNIT_TEST_SUITE_REGISTRATION(BackendTest);
1641
1642 CPPUNIT_PLUGIN_IMPLEMENT();
1643
1644 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */