1# -*- coding: utf-8 -*-
2"""QGIS Unit tests for QgsTextRenderer.
3
4.. note:: This program is free software; you can redistribute it and/or modify
5it under the terms of the GNU General Public License as published by
6the Free Software Foundation; either version 2 of the License, or
7(at your option) any later version.
8"""
9__author__ = 'Nyall Dawson'
10__date__ = '2016-09'
11__copyright__ = 'Copyright 2016, The QGIS Project'
12
13import qgis  # NOQA
14import os
15
16from qgis.core import (QgsTextBufferSettings,
17                       QgsTextMaskSettings,
18                       QgsTextBackgroundSettings,
19                       QgsTextShadowSettings,
20                       QgsTextFormat,
21                       QgsUnitTypes,
22                       QgsMapUnitScale,
23                       QgsVectorLayer,
24                       QgsTextRenderer,
25                       QgsMapSettings,
26                       QgsReadWriteContext,
27                       QgsRenderContext,
28                       QgsRectangle,
29                       QgsRenderChecker,
30                       QgsBlurEffect,
31                       QgsMarkerSymbol,
32                       QgsPalLayerSettings,
33                       QgsProperty,
34                       QgsFontUtils,
35                       QgsSymbolLayerId,
36                       QgsSymbolLayerReference,
37                       QgsStringUtils)
38from qgis.PyQt.QtGui import (QColor, QPainter, QFont, QImage, QBrush, QPen, QFontMetricsF)
39from qgis.PyQt.QtCore import (Qt, QSizeF, QPointF, QRectF, QDir, QSize)
40from qgis.PyQt.QtXml import QDomDocument
41from PyQt5.QtSvg import QSvgGenerator
42from qgis.testing import unittest, start_app
43from utilities import getTestFont, svgSymbolsPath
44
45start_app()
46
47
48def createEmptyLayer():
49    layer = QgsVectorLayer("Point", "addfeat", "memory")
50    assert layer.isValid()
51    return layer
52
53
54class PyQgsTextRenderer(unittest.TestCase):
55
56    @classmethod
57    def setUpClass(cls):
58        cls.report = "<h1>Python QgsTextRenderer Tests</h1>\n"
59        QgsFontUtils.loadStandardTestFonts(['Bold', 'Oblique'])
60
61    @classmethod
62    def tearDownClass(cls):
63        report_file_path = "%s/qgistest.html" % QDir.tempPath()
64        with open(report_file_path, 'a') as report_file:
65            report_file.write(cls.report)
66
67    def testValid(self):
68        t = QgsTextFormat()
69        self.assertFalse(t.isValid())
70
71        tt = QgsTextFormat(t)
72        self.assertFalse(tt.isValid())
73
74        t.setValid()
75        self.assertTrue(t.isValid())
76        tt = QgsTextFormat(t)
77        self.assertTrue(tt.isValid())
78
79        doc = QDomDocument()
80        elem = t.writeXml(doc, QgsReadWriteContext())
81        parent = doc.createElement("settings")
82        parent.appendChild(elem)
83        t3 = QgsTextFormat()
84        t3.readXml(parent, QgsReadWriteContext())
85        self.assertTrue(t3.isValid())
86
87        t = QgsTextFormat()
88        t.buffer().setEnabled(True)
89        self.assertTrue(t.isValid())
90
91        t = QgsTextFormat()
92        t.background().setEnabled(True)
93        self.assertTrue(t.isValid())
94
95        t = QgsTextFormat()
96        t.shadow().setEnabled(True)
97        self.assertTrue(t.isValid())
98
99        t = QgsTextFormat()
100        t.mask().setEnabled(True)
101        self.assertTrue(t.isValid())
102
103        t = QgsTextFormat()
104        t.font()
105        self.assertFalse(t.isValid())
106        t.setFont(QFont())
107        self.assertTrue(t.isValid())
108
109        t = QgsTextFormat()
110        t.setNamedStyle('Bold')
111        self.assertTrue(t.isValid())
112
113        t = QgsTextFormat()
114        t.setSize(20)
115        self.assertTrue(t.isValid())
116
117        t = QgsTextFormat()
118        t.setSizeUnit(QgsUnitTypes.RenderPixels)
119        self.assertTrue(t.isValid())
120
121        t = QgsTextFormat()
122        t.setSizeMapUnitScale(QgsMapUnitScale(5, 10))
123        self.assertTrue(t.isValid())
124
125        t = QgsTextFormat()
126        t.setColor(QColor(255, 0, 0))
127        self.assertTrue(t.isValid())
128
129        t = QgsTextFormat()
130        t.setOpacity(0.2)
131        self.assertTrue(t.isValid())
132
133        t = QgsTextFormat()
134        t.setBlendMode(QPainter.CompositionMode_Darken)
135        self.assertTrue(t.isValid())
136
137        t = QgsTextFormat()
138        t.setLineHeight(20)
139        self.assertTrue(t.isValid())
140
141        t = QgsTextFormat()
142        t.setOrientation(QgsTextFormat.VerticalOrientation)
143        self.assertTrue(t.isValid())
144
145        t = QgsTextFormat()
146        t.setCapitalization(QgsStringUtils.TitleCase)
147        self.assertTrue(t.isValid())
148
149        t = QgsTextFormat()
150        t.setAllowHtmlFormatting(True)
151        self.assertTrue(t.isValid())
152
153        t = QgsTextFormat()
154        t.setPreviewBackgroundColor(QColor(255, 0, 0))
155        self.assertTrue(t.isValid())
156
157        t = QgsTextFormat()
158        t.dataDefinedProperties().setProperty(QgsPalLayerSettings.Bold, QgsProperty.fromValue(True))
159        self.assertTrue(t.isValid())
160
161    def testAlignmentConversion(self):
162        self.assertEqual(QgsTextRenderer.convertQtHAlignment(Qt.AlignLeft), QgsTextRenderer.AlignLeft)
163        self.assertEqual(QgsTextRenderer.convertQtHAlignment(Qt.AlignRight), QgsTextRenderer.AlignRight)
164        self.assertEqual(QgsTextRenderer.convertQtHAlignment(Qt.AlignHCenter), QgsTextRenderer.AlignCenter)
165        self.assertEqual(QgsTextRenderer.convertQtHAlignment(Qt.AlignJustify), QgsTextRenderer.AlignJustify)
166        # not supported, should fallback to left
167        self.assertEqual(QgsTextRenderer.convertQtHAlignment(Qt.AlignAbsolute), QgsTextRenderer.AlignLeft)
168
169        self.assertEqual(QgsTextRenderer.convertQtVAlignment(Qt.AlignTop), QgsTextRenderer.AlignTop)
170        self.assertEqual(QgsTextRenderer.convertQtVAlignment(Qt.AlignBottom), QgsTextRenderer.AlignBottom)
171        self.assertEqual(QgsTextRenderer.convertQtVAlignment(Qt.AlignVCenter), QgsTextRenderer.AlignVCenter)
172        # note supported, should fallback to bottom
173        self.assertEqual(QgsTextRenderer.convertQtVAlignment(Qt.AlignBaseline), QgsTextRenderer.AlignBottom)
174
175    def createBufferSettings(self):
176        s = QgsTextBufferSettings()
177        s.setEnabled(True)
178        s.setSize(5)
179        s.setSizeUnit(QgsUnitTypes.RenderPoints)
180        s.setSizeMapUnitScale(QgsMapUnitScale(1, 2))
181        s.setColor(QColor(255, 0, 0))
182        s.setFillBufferInterior(True)
183        s.setOpacity(0.5)
184        s.setJoinStyle(Qt.RoundJoin)
185        s.setBlendMode(QPainter.CompositionMode_DestinationAtop)
186        return s
187
188    def testBufferEquality(self):
189        s = self.createBufferSettings()
190        s2 = self.createBufferSettings()
191        self.assertEqual(s, s2)
192
193        s.setEnabled(False)
194        self.assertNotEqual(s, s2)
195        s = self.createBufferSettings()
196
197        s.setSize(15)
198        self.assertNotEqual(s, s2)
199        s = self.createBufferSettings()
200
201        s.setSizeUnit(QgsUnitTypes.RenderPixels)
202        self.assertNotEqual(s, s2)
203        s = self.createBufferSettings()
204
205        s.setSizeMapUnitScale(QgsMapUnitScale(11, 12))
206        self.assertNotEqual(s, s2)
207        s = self.createBufferSettings()
208
209        s.setColor(QColor(255, 255, 0))
210        self.assertNotEqual(s, s2)
211        s = self.createBufferSettings()
212
213        s.setFillBufferInterior(False)
214        self.assertNotEqual(s, s2)
215        s = self.createBufferSettings()
216
217        s.setOpacity(0.6)
218        self.assertNotEqual(s, s2)
219        s = self.createBufferSettings()
220
221        s.setJoinStyle(Qt.MiterJoin)
222        self.assertNotEqual(s, s2)
223        s = self.createBufferSettings()
224
225        s.setBlendMode(QPainter.CompositionMode_Darken)
226        self.assertNotEqual(s, s2)
227
228    def checkBufferSettings(self, s):
229        """ test QgsTextBufferSettings """
230        self.assertTrue(s.enabled())
231        self.assertEqual(s.size(), 5)
232        self.assertEqual(s.sizeUnit(), QgsUnitTypes.RenderPoints)
233        self.assertEqual(s.sizeMapUnitScale(), QgsMapUnitScale(1, 2))
234        self.assertEqual(s.color(), QColor(255, 0, 0))
235        self.assertTrue(s.fillBufferInterior())
236        self.assertEqual(s.opacity(), 0.5)
237        self.assertEqual(s.joinStyle(), Qt.RoundJoin)
238        self.assertEqual(s.blendMode(), QPainter.CompositionMode_DestinationAtop)
239
240    def testBufferGettersSetters(self):
241        s = self.createBufferSettings()
242        self.checkBufferSettings(s)
243
244        # some other checks
245        s.setEnabled(False)
246        self.assertFalse(s.enabled())
247        s.setEnabled(True)
248        self.assertTrue(s.enabled())
249        s.setFillBufferInterior(False)
250        self.assertFalse(s.fillBufferInterior())
251        s.setFillBufferInterior(True)
252        self.assertTrue(s.fillBufferInterior())
253
254    def testBufferReadWriteXml(self):
255        """test saving and restoring state of a buffer to xml"""
256        doc = QDomDocument("testdoc")
257        s = self.createBufferSettings()
258        elem = s.writeXml(doc)
259        parent = doc.createElement("settings")
260        parent.appendChild(elem)
261        t = QgsTextBufferSettings()
262        t.readXml(parent)
263        self.checkBufferSettings(t)
264
265    def testBufferCopy(self):
266        s = self.createBufferSettings()
267        s2 = s
268        self.checkBufferSettings(s2)
269        s3 = QgsTextBufferSettings(s)
270        self.checkBufferSettings(s3)
271
272    def createMaskSettings(self):
273        s = QgsTextMaskSettings()
274        s.setEnabled(True)
275        s.setType(QgsTextMaskSettings.MaskBuffer)
276        s.setSize(5)
277        s.setSizeUnit(QgsUnitTypes.RenderPoints)
278        s.setSizeMapUnitScale(QgsMapUnitScale(1, 2))
279        s.setOpacity(0.5)
280        s.setJoinStyle(Qt.RoundJoin)
281        s.setMaskedSymbolLayers([QgsSymbolLayerReference("layerid1", QgsSymbolLayerId("symbol", 1)),
282                                 QgsSymbolLayerReference("layerid2", QgsSymbolLayerId("symbol2", 2))])
283        return s
284
285    def testMaskEquality(self):
286        s = self.createMaskSettings()
287        s2 = self.createMaskSettings()
288        self.assertEqual(s, s2)
289
290        s.setEnabled(False)
291        self.assertNotEqual(s, s2)
292        s = self.createMaskSettings()
293
294        s.setSize(15)
295        self.assertNotEqual(s, s2)
296        s = self.createMaskSettings()
297
298        s.setSizeUnit(QgsUnitTypes.RenderPixels)
299        self.assertNotEqual(s, s2)
300        s = self.createMaskSettings()
301
302        s.setSizeMapUnitScale(QgsMapUnitScale(11, 12))
303        self.assertNotEqual(s, s2)
304        s = self.createMaskSettings()
305
306        s.setOpacity(0.6)
307        self.assertNotEqual(s, s2)
308        s = self.createMaskSettings()
309
310        s.setJoinStyle(Qt.MiterJoin)
311        self.assertNotEqual(s, s2)
312        s = self.createMaskSettings()
313
314        s.setMaskedSymbolLayers([QgsSymbolLayerReference("layerid11", QgsSymbolLayerId("symbol", 1)),
315                                 QgsSymbolLayerReference("layerid21", QgsSymbolLayerId("symbol2", 2))])
316        self.assertNotEqual(s, s2)
317
318    def checkMaskSettings(self, s):
319        """ test QgsTextMaskSettings """
320        self.assertTrue(s.enabled())
321        self.assertEqual(s.type(), QgsTextMaskSettings.MaskBuffer)
322        self.assertEqual(s.size(), 5)
323        self.assertEqual(s.sizeUnit(), QgsUnitTypes.RenderPoints)
324        self.assertEqual(s.sizeMapUnitScale(), QgsMapUnitScale(1, 2))
325        self.assertEqual(s.opacity(), 0.5)
326        self.assertEqual(s.joinStyle(), Qt.RoundJoin)
327        self.assertEqual(s.maskedSymbolLayers(), [QgsSymbolLayerReference("layerid1", QgsSymbolLayerId("symbol", 1)),
328                                                  QgsSymbolLayerReference("layerid2", QgsSymbolLayerId("symbol2", 2))])
329
330    def testMaskGettersSetters(self):
331        s = self.createMaskSettings()
332        self.checkMaskSettings(s)
333
334        # some other checks
335        s.setEnabled(False)
336        self.assertFalse(s.enabled())
337
338    def testMaskReadWriteXml(self):
339        """test saving and restoring state of a mask to xml"""
340        doc = QDomDocument("testdoc")
341        s = self.createMaskSettings()
342        elem = s.writeXml(doc)
343        parent = doc.createElement("settings")
344        parent.appendChild(elem)
345        t = QgsTextMaskSettings()
346        t.readXml(parent)
347        self.checkMaskSettings(t)
348
349    def testMaskCopy(self):
350        s = self.createMaskSettings()
351        s2 = s
352        self.checkMaskSettings(s2)
353        s3 = QgsTextMaskSettings(s)
354        self.checkMaskSettings(s3)
355
356    def createBackgroundSettings(self):
357        s = QgsTextBackgroundSettings()
358        s.setEnabled(True)
359        s.setType(QgsTextBackgroundSettings.ShapeEllipse)
360        s.setSvgFile('svg.svg')
361        s.setSizeType(QgsTextBackgroundSettings.SizePercent)
362        s.setSize(QSizeF(1, 2))
363        s.setSizeUnit(QgsUnitTypes.RenderPoints)
364        s.setSizeMapUnitScale(QgsMapUnitScale(1, 2))
365        s.setRotationType(QgsTextBackgroundSettings.RotationFixed)
366        s.setRotation(45)
367        s.setOffset(QPointF(3, 4))
368        s.setOffsetUnit(QgsUnitTypes.RenderMapUnits)
369        s.setOffsetMapUnitScale(QgsMapUnitScale(5, 6))
370        s.setRadii(QSizeF(11, 12))
371        s.setRadiiUnit(QgsUnitTypes.RenderPercentage)
372        s.setRadiiMapUnitScale(QgsMapUnitScale(15, 16))
373        s.setFillColor(QColor(255, 0, 0))
374        s.setStrokeColor(QColor(0, 255, 0))
375        s.setOpacity(0.5)
376        s.setJoinStyle(Qt.RoundJoin)
377        s.setBlendMode(QPainter.CompositionMode_DestinationAtop)
378        s.setStrokeWidth(7)
379        s.setStrokeWidthUnit(QgsUnitTypes.RenderPoints)
380        s.setStrokeWidthMapUnitScale(QgsMapUnitScale(QgsMapUnitScale(25, 26)))
381
382        marker = QgsMarkerSymbol()
383        marker.setColor(QColor(100, 112, 134))
384        s.setMarkerSymbol(marker)
385
386        return s
387
388    def testBackgroundEquality(self):
389        s = self.createBackgroundSettings()
390        s2 = self.createBackgroundSettings()
391        self.assertEqual(s, s2)
392
393        s.setEnabled(False)
394        self.assertNotEqual(s, s2)
395        s = self.createBackgroundSettings()
396
397        s.setType(QgsTextBackgroundSettings.ShapeRectangle)
398        self.assertNotEqual(s, s2)
399        s = self.createBackgroundSettings()
400
401        s.setSvgFile('svg2.svg')
402        self.assertNotEqual(s, s2)
403        s = self.createBackgroundSettings()
404
405        s.setSizeType(QgsTextBackgroundSettings.SizeFixed)
406        self.assertNotEqual(s, s2)
407        s = self.createBackgroundSettings()
408
409        s.setSize(QSizeF(1, 22))
410        self.assertNotEqual(s, s2)
411        s = self.createBackgroundSettings()
412
413        s.setSizeUnit(QgsUnitTypes.RenderPixels)
414        self.assertNotEqual(s, s2)
415        s = self.createBackgroundSettings()
416
417        s.setSizeMapUnitScale(QgsMapUnitScale(11, 22))
418        self.assertNotEqual(s, s2)
419        s = self.createBackgroundSettings()
420
421        s.setRotationType(QgsTextBackgroundSettings.RotationSync)
422        self.assertNotEqual(s, s2)
423        s = self.createBackgroundSettings()
424
425        s.setRotation(145)
426        self.assertNotEqual(s, s2)
427        s = self.createBackgroundSettings()
428
429        s.setOffset(QPointF(31, 41))
430        self.assertNotEqual(s, s2)
431        s = self.createBackgroundSettings()
432
433        s.setOffsetUnit(QgsUnitTypes.RenderPixels)
434        self.assertNotEqual(s, s2)
435        s = self.createBackgroundSettings()
436
437        s.setOffsetMapUnitScale(QgsMapUnitScale(15, 16))
438        self.assertNotEqual(s, s2)
439        s = self.createBackgroundSettings()
440
441        s.setRadii(QSizeF(111, 112))
442        self.assertNotEqual(s, s2)
443        s = self.createBackgroundSettings()
444
445        s.setRadiiUnit(QgsUnitTypes.RenderPoints)
446        self.assertNotEqual(s, s2)
447        s = self.createBackgroundSettings()
448
449        s.setRadiiMapUnitScale(QgsMapUnitScale(151, 161))
450        self.assertNotEqual(s, s2)
451        s = self.createBackgroundSettings()
452
453        s.setFillColor(QColor(255, 255, 0))
454        self.assertNotEqual(s, s2)
455        s = self.createBackgroundSettings()
456
457        s.setStrokeColor(QColor(0, 255, 255))
458        self.assertNotEqual(s, s2)
459        s = self.createBackgroundSettings()
460
461        s.setOpacity(0.6)
462        self.assertNotEqual(s, s2)
463        s = self.createBackgroundSettings()
464
465        s.setJoinStyle(Qt.MiterJoin)
466        self.assertNotEqual(s, s2)
467        s = self.createBackgroundSettings()
468
469        s.setBlendMode(QPainter.CompositionMode_Darken)
470        self.assertNotEqual(s, s2)
471        s = self.createBackgroundSettings()
472
473        s.setStrokeWidth(17)
474        self.assertNotEqual(s, s2)
475        s = self.createBackgroundSettings()
476
477        s.setStrokeWidthUnit(QgsUnitTypes.RenderPixels)
478        self.assertNotEqual(s, s2)
479        s = self.createBackgroundSettings()
480
481        s.setStrokeWidthMapUnitScale(QgsMapUnitScale(QgsMapUnitScale(251, 261)))
482        self.assertNotEqual(s, s2)
483
484    def checkBackgroundSettings(self, s):
485        """ test QgsTextBackgroundSettings """
486        self.assertTrue(s.enabled())
487        self.assertEqual(s.type(), QgsTextBackgroundSettings.ShapeEllipse)
488        self.assertEqual(s.svgFile(), 'svg.svg')
489        self.assertEqual(s.sizeType(), QgsTextBackgroundSettings.SizePercent)
490        self.assertEqual(s.size(), QSizeF(1, 2))
491        self.assertEqual(s.sizeUnit(), QgsUnitTypes.RenderPoints)
492        self.assertEqual(s.sizeMapUnitScale(), QgsMapUnitScale(1, 2))
493        self.assertEqual(s.rotationType(), QgsTextBackgroundSettings.RotationFixed)
494        self.assertEqual(s.rotation(), 45)
495        self.assertEqual(s.offset(), QPointF(3, 4))
496        self.assertEqual(s.offsetUnit(), QgsUnitTypes.RenderMapUnits)
497        self.assertEqual(s.offsetMapUnitScale(), QgsMapUnitScale(5, 6))
498        self.assertEqual(s.radii(), QSizeF(11, 12))
499        self.assertEqual(s.radiiUnit(), QgsUnitTypes.RenderPercentage)
500        self.assertEqual(s.radiiMapUnitScale(), QgsMapUnitScale(15, 16))
501        self.assertEqual(s.fillColor(), QColor(255, 0, 0))
502        self.assertEqual(s.strokeColor(), QColor(0, 255, 0))
503        self.assertEqual(s.opacity(), 0.5)
504        self.assertEqual(s.joinStyle(), Qt.RoundJoin)
505        self.assertEqual(s.blendMode(), QPainter.CompositionMode_DestinationAtop)
506        self.assertEqual(s.strokeWidth(), 7)
507        self.assertEqual(s.strokeWidthUnit(), QgsUnitTypes.RenderPoints)
508        self.assertEqual(s.strokeWidthMapUnitScale(), QgsMapUnitScale(25, 26))
509        self.assertEqual(s.markerSymbol().color().name(), '#647086')
510
511    def testBackgroundGettersSetters(self):
512        s = self.createBackgroundSettings()
513        self.checkBackgroundSettings(s)
514
515        # some other checks
516        s.setEnabled(False)
517        self.assertFalse(s.enabled())
518        s.setEnabled(True)
519        self.assertTrue(s.enabled())
520
521    def testBackgroundCopy(self):
522        s = self.createBackgroundSettings()
523        s2 = s
524        self.checkBackgroundSettings(s2)
525        s3 = QgsTextBackgroundSettings(s)
526        self.checkBackgroundSettings(s3)
527
528    def testBackgroundReadWriteXml(self):
529        """test saving and restoring state of a background to xml"""
530        doc = QDomDocument("testdoc")
531        s = self.createBackgroundSettings()
532        elem = s.writeXml(doc, QgsReadWriteContext())
533        parent = doc.createElement("settings")
534        parent.appendChild(elem)
535        t = QgsTextBackgroundSettings()
536        t.readXml(parent, QgsReadWriteContext())
537        self.checkBackgroundSettings(t)
538
539    def createShadowSettings(self):
540        s = QgsTextShadowSettings()
541        s.setEnabled(True)
542        s.setShadowPlacement(QgsTextShadowSettings.ShadowBuffer)
543        s.setOffsetAngle(45)
544        s.setOffsetDistance(75)
545        s.setOffsetUnit(QgsUnitTypes.RenderMapUnits)
546        s.setOffsetMapUnitScale(QgsMapUnitScale(5, 6))
547        s.setOffsetGlobal(True)
548        s.setBlurRadius(11)
549        s.setBlurRadiusUnit(QgsUnitTypes.RenderPercentage)
550        s.setBlurRadiusMapUnitScale(QgsMapUnitScale(15, 16))
551        s.setBlurAlphaOnly(True)
552        s.setColor(QColor(255, 0, 0))
553        s.setOpacity(0.5)
554        s.setScale(123)
555        s.setBlendMode(QPainter.CompositionMode_DestinationAtop)
556        return s
557
558    def testShadowEquality(self):
559        s = self.createShadowSettings()
560        s2 = self.createShadowSettings()
561        self.assertEqual(s, s2)
562
563        s.setEnabled(False)
564        self.assertNotEqual(s, s2)
565        s = self.createShadowSettings()
566
567        s.setShadowPlacement(QgsTextShadowSettings.ShadowText)
568        self.assertNotEqual(s, s2)
569        s = self.createShadowSettings()
570
571        s.setOffsetAngle(145)
572        self.assertNotEqual(s, s2)
573        s = self.createShadowSettings()
574
575        s.setOffsetDistance(175)
576        self.assertNotEqual(s, s2)
577        s = self.createShadowSettings()
578
579        s.setOffsetUnit(QgsUnitTypes.RenderPixels)
580        self.assertNotEqual(s, s2)
581        s = self.createShadowSettings()
582
583        s.setOffsetMapUnitScale(QgsMapUnitScale(15, 16))
584        self.assertNotEqual(s, s2)
585        s = self.createShadowSettings()
586
587        s.setOffsetGlobal(False)
588        self.assertNotEqual(s, s2)
589        s = self.createShadowSettings()
590
591        s.setBlurRadius(21)
592        self.assertNotEqual(s, s2)
593        s = self.createShadowSettings()
594
595        s.setBlurRadiusUnit(QgsUnitTypes.RenderPoints)
596        self.assertNotEqual(s, s2)
597        s = self.createShadowSettings()
598
599        s.setBlurRadiusMapUnitScale(QgsMapUnitScale(115, 116))
600        self.assertNotEqual(s, s2)
601        s = self.createShadowSettings()
602
603        s.setBlurAlphaOnly(False)
604        self.assertNotEqual(s, s2)
605        s = self.createShadowSettings()
606
607        s.setColor(QColor(255, 255, 0))
608        self.assertNotEqual(s, s2)
609        s = self.createShadowSettings()
610
611        s.setOpacity(0.6)
612        self.assertNotEqual(s, s2)
613        s = self.createShadowSettings()
614
615        s.setScale(23)
616        self.assertNotEqual(s, s2)
617        s = self.createShadowSettings()
618
619        s.setBlendMode(QPainter.CompositionMode_Darken)
620        self.assertNotEqual(s, s2)
621
622    def checkShadowSettings(self, s):
623        """ test QgsTextShadowSettings """
624        self.assertTrue(s.enabled())
625        self.assertEqual(s.shadowPlacement(), QgsTextShadowSettings.ShadowBuffer)
626        self.assertEqual(s.offsetAngle(), 45)
627        self.assertEqual(s.offsetDistance(), 75)
628        self.assertEqual(s.offsetUnit(), QgsUnitTypes.RenderMapUnits)
629        self.assertEqual(s.offsetMapUnitScale(), QgsMapUnitScale(5, 6))
630        self.assertTrue(s.offsetGlobal())
631        self.assertEqual(s.blurRadius(), 11)
632        self.assertEqual(s.blurRadiusUnit(), QgsUnitTypes.RenderPercentage)
633        self.assertEqual(s.blurRadiusMapUnitScale(), QgsMapUnitScale(15, 16))
634        self.assertTrue(s.blurAlphaOnly())
635        self.assertEqual(s.color(), QColor(255, 0, 0))
636        self.assertEqual(s.opacity(), 0.5)
637        self.assertEqual(s.scale(), 123)
638        self.assertEqual(s.blendMode(), QPainter.CompositionMode_DestinationAtop)
639
640    def testShadowGettersSetters(self):
641        s = self.createShadowSettings()
642        self.checkShadowSettings(s)
643
644        # some other checks
645        s.setEnabled(False)
646        self.assertFalse(s.enabled())
647        s.setEnabled(True)
648        self.assertTrue(s.enabled())
649        s.setOffsetGlobal(False)
650        self.assertFalse(s.offsetGlobal())
651        s.setOffsetGlobal(True)
652        self.assertTrue(s.offsetGlobal())
653        s.setBlurAlphaOnly(False)
654        self.assertFalse(s.blurAlphaOnly())
655        s.setBlurAlphaOnly(True)
656        self.assertTrue(s.blurAlphaOnly())
657
658    def testShadowCopy(self):
659        s = self.createShadowSettings()
660        s2 = s
661        self.checkShadowSettings(s2)
662        s3 = QgsTextShadowSettings(s)
663        self.checkShadowSettings(s3)
664
665    def testShadowReadWriteXml(self):
666        """test saving and restoring state of a shadow to xml"""
667        doc = QDomDocument("testdoc")
668        s = self.createShadowSettings()
669        elem = s.writeXml(doc)
670        parent = doc.createElement("settings")
671        parent.appendChild(elem)
672        t = QgsTextShadowSettings()
673        t.readXml(parent)
674        self.checkShadowSettings(t)
675
676    def createFormatSettings(self):
677        s = QgsTextFormat()
678        s.buffer().setEnabled(True)
679        s.buffer().setSize(25)
680        s.mask().setEnabled(True)
681        s.mask().setSize(32)
682        s.background().setEnabled(True)
683        s.background().setSvgFile('test.svg')
684        s.shadow().setEnabled(True)
685        s.shadow().setOffsetAngle(223)
686        font = getTestFont()
687        font.setKerning(False)
688        s.setFont(font)
689        s.setCapitalization(QgsStringUtils.TitleCase)
690        s.setNamedStyle('Italic')
691        s.setSize(5)
692        s.setSizeUnit(QgsUnitTypes.RenderPoints)
693        s.setSizeMapUnitScale(QgsMapUnitScale(1, 2))
694        s.setColor(QColor(255, 0, 0))
695        s.setOpacity(0.5)
696        s.setBlendMode(QPainter.CompositionMode_DestinationAtop)
697        s.setLineHeight(5)
698        s.setPreviewBackgroundColor(QColor(100, 150, 200))
699        s.setOrientation(QgsTextFormat.VerticalOrientation)
700        s.setAllowHtmlFormatting(True)
701        s.dataDefinedProperties().setProperty(QgsPalLayerSettings.Bold, QgsProperty.fromExpression('1>2'))
702        return s
703
704    def testFormatEquality(self):
705        s = self.createFormatSettings()
706        s2 = self.createFormatSettings()
707        self.assertEqual(s, s2)
708
709        s.buffer().setEnabled(False)
710        self.assertNotEqual(s, s2)
711        s = self.createFormatSettings()
712
713        s.buffer().setSize(12)
714        self.assertNotEqual(s, s2)
715        s = self.createFormatSettings()
716
717        s.mask().setEnabled(False)
718        self.assertNotEqual(s, s2)
719        s = self.createFormatSettings()
720
721        s.mask().setSize(12)
722        self.assertNotEqual(s, s2)
723        s = self.createFormatSettings()
724
725        s.background().setEnabled(False)
726        self.assertNotEqual(s, s2)
727        s = self.createFormatSettings()
728
729        s.background().setSvgFile('test2.svg')
730        self.assertNotEqual(s, s2)
731        s = self.createFormatSettings()
732
733        s.shadow().setEnabled(False)
734        self.assertNotEqual(s, s2)
735        s = self.createFormatSettings()
736
737        s.shadow().setOffsetAngle(123)
738        self.assertNotEqual(s, s2)
739        s = self.createFormatSettings()
740
741        font = getTestFont()
742        font.setKerning(True)
743        s.setFont(font)
744        self.assertNotEqual(s, s2)
745        s = self.createFormatSettings()
746
747        s.setNamedStyle('Bold')
748        self.assertNotEqual(s, s2)
749        s = self.createFormatSettings()
750
751        s.setSize(15)
752        self.assertNotEqual(s, s2)
753        s = self.createFormatSettings()
754
755        s.setSizeUnit(QgsUnitTypes.RenderPixels)
756        self.assertNotEqual(s, s2)
757        s = self.createFormatSettings()
758
759        s.setSizeMapUnitScale(QgsMapUnitScale(11, 12))
760        self.assertNotEqual(s, s2)
761        s = self.createFormatSettings()
762
763        s.setColor(QColor(255, 255, 0))
764        self.assertNotEqual(s, s2)
765        s = self.createFormatSettings()
766
767        s.setOpacity(0.6)
768        self.assertNotEqual(s, s2)
769        s = self.createFormatSettings()
770
771        s.setBlendMode(QPainter.CompositionMode_Darken)
772        self.assertNotEqual(s, s2)
773        s = self.createFormatSettings()
774
775        s.setLineHeight(15)
776        self.assertNotEqual(s, s2)
777        s = self.createFormatSettings()
778
779        s.setPreviewBackgroundColor(QColor(100, 250, 200))
780        self.assertNotEqual(s, s2)
781        s = self.createFormatSettings()
782
783        s.setOrientation(QgsTextFormat.HorizontalOrientation)
784        self.assertNotEqual(s, s2)
785        s = self.createFormatSettings()
786
787        s.setAllowHtmlFormatting(False)
788        self.assertNotEqual(s, s2)
789        s = self.createFormatSettings()
790
791        s.setCapitalization(QgsStringUtils.ForceFirstLetterToCapital)
792        self.assertNotEqual(s, s2)
793        s = self.createFormatSettings()
794
795        s.dataDefinedProperties().setProperty(QgsPalLayerSettings.Bold, QgsProperty.fromExpression('1>3'))
796        self.assertNotEqual(s, s2)
797
798    def checkTextFormat(self, s):
799        """ test QgsTextFormat """
800        self.assertTrue(s.buffer().enabled())
801        self.assertEqual(s.buffer().size(), 25)
802        self.assertTrue(s.mask().enabled())
803        self.assertEqual(s.mask().size(), 32)
804        self.assertTrue(s.background().enabled())
805        self.assertEqual(s.background().svgFile(), 'test.svg')
806        self.assertTrue(s.shadow().enabled())
807        self.assertEqual(s.shadow().offsetAngle(), 223)
808        self.assertEqual(s.font().family(), 'QGIS Vera Sans')
809        self.assertFalse(s.font().kerning())
810        self.assertEqual(s.namedStyle(), 'Italic')
811        self.assertEqual(s.size(), 5)
812        self.assertEqual(s.sizeUnit(), QgsUnitTypes.RenderPoints)
813        self.assertEqual(s.sizeMapUnitScale(), QgsMapUnitScale(1, 2))
814        self.assertEqual(s.color(), QColor(255, 0, 0))
815        self.assertEqual(s.opacity(), 0.5)
816        self.assertEqual(s.blendMode(), QPainter.CompositionMode_DestinationAtop)
817        self.assertEqual(s.lineHeight(), 5)
818        self.assertEqual(s.previewBackgroundColor().name(), '#6496c8')
819        self.assertEqual(s.orientation(), QgsTextFormat.VerticalOrientation)
820        self.assertEqual(s.capitalization(), QgsStringUtils.TitleCase)
821        self.assertTrue(s.allowHtmlFormatting())
822        self.assertEqual(s.dataDefinedProperties().property(QgsPalLayerSettings.Bold).expressionString(), '1>2')
823
824    def testFormatGettersSetters(self):
825        s = self.createFormatSettings()
826        self.checkTextFormat(s)
827
828    def testFormatCopy(self):
829        s = self.createFormatSettings()
830        s2 = s
831        self.checkTextFormat(s2)
832        s3 = QgsTextFormat(s)
833        self.checkTextFormat(s3)
834
835    def testFormatReadWriteXml(self):
836        """test saving and restoring state of a shadow to xml"""
837        doc = QDomDocument("testdoc")
838        s = self.createFormatSettings()
839        elem = s.writeXml(doc, QgsReadWriteContext())
840        parent = doc.createElement("settings")
841        parent.appendChild(elem)
842        t = QgsTextFormat()
843        t.readXml(parent, QgsReadWriteContext())
844        self.checkTextFormat(t)
845
846    def testFormatToFromMimeData(self):
847        """Test converting format to and from mime data"""
848        s = self.createFormatSettings()
849        md = s.toMimeData()
850        from_mime, ok = QgsTextFormat.fromMimeData(None)
851        self.assertFalse(ok)
852        from_mime, ok = QgsTextFormat.fromMimeData(md)
853        self.assertTrue(ok)
854        self.checkTextFormat(from_mime)
855
856    def containsAdvancedEffects(self):
857        t = QgsTextFormat()
858        self.assertFalse(t.containsAdvancedEffects())
859        t.setBlendMode(QPainter.CompositionMode_DestinationAtop)
860        self.assertTrue(t.containsAdvancedEffects())
861
862        t = QgsTextFormat()
863        t.buffer().setBlendMode(QPainter.CompositionMode_DestinationAtop)
864        self.assertFalse(t.containsAdvancedEffects())
865        t.buffer().setEnabled(True)
866        self.assertTrue(t.containsAdvancedEffects())
867        t.buffer().setBlendMode(QPainter.CompositionMode_SourceOver)
868        self.assertFalse(t.containsAdvancedEffects())
869
870        t = QgsTextFormat()
871        t.background().setBlendMode(QPainter.CompositionMode_DestinationAtop)
872        self.assertFalse(t.containsAdvancedEffects())
873        t.background().setEnabled(True)
874        self.assertTrue(t.containsAdvancedEffects())
875        t.background().setBlendMode(QPainter.CompositionMode_SourceOver)
876        self.assertFalse(t.containsAdvancedEffects())
877
878        t = QgsTextFormat()
879        t.shadow().setBlendMode(QPainter.CompositionMode_DestinationAtop)
880        self.assertFalse(t.containsAdvancedEffects())
881        t.shadow().setEnabled(True)
882        self.assertTrue(t.containsAdvancedEffects())
883        t.shadow().setBlendMode(QPainter.CompositionMode_SourceOver)
884        self.assertFalse(t.containsAdvancedEffects())
885
886    def testDataDefinedBufferSettings(self):
887        f = QgsTextFormat()
888        context = QgsRenderContext()
889
890        # buffer enabled
891        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.BufferDraw, QgsProperty.fromExpression('1'))
892        f.updateDataDefinedProperties(context)
893        self.assertTrue(f.buffer().enabled())
894        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.BufferDraw, QgsProperty.fromExpression('0'))
895        context = QgsRenderContext()
896        f.updateDataDefinedProperties(context)
897        self.assertFalse(f.buffer().enabled())
898
899        # buffer size
900        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.BufferSize, QgsProperty.fromExpression('7.8'))
901        f.updateDataDefinedProperties(context)
902        self.assertEqual(f.buffer().size(), 7.8)
903        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.BufferUnit, QgsProperty.fromExpression("'pixel'"))
904        f.updateDataDefinedProperties(context)
905        self.assertEqual(f.buffer().sizeUnit(), QgsUnitTypes.RenderPixels)
906
907        # buffer opacity
908        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.BufferOpacity, QgsProperty.fromExpression('37'))
909        f.updateDataDefinedProperties(context)
910        self.assertEqual(f.buffer().opacity(), 0.37)
911
912        # blend mode
913        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.BufferBlendMode, QgsProperty.fromExpression("'burn'"))
914        f.updateDataDefinedProperties(context)
915        self.assertEqual(f.buffer().blendMode(), QPainter.CompositionMode_ColorBurn)
916
917        # join style
918        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.BufferJoinStyle,
919                                              QgsProperty.fromExpression("'miter'"))
920        f.updateDataDefinedProperties(context)
921        self.assertEqual(f.buffer().joinStyle(), Qt.MiterJoin)
922
923        # color
924        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.BufferColor, QgsProperty.fromExpression("'#ff0088'"))
925        f.updateDataDefinedProperties(context)
926        self.assertEqual(f.buffer().color().name(), '#ff0088')
927
928    def testDataDefinedMaskSettings(self):
929        f = QgsTextFormat()
930        context = QgsRenderContext()
931
932        # mask enabled
933        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.MaskEnabled, QgsProperty.fromExpression('1'))
934        f.updateDataDefinedProperties(context)
935        self.assertTrue(f.mask().enabled())
936        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.MaskEnabled, QgsProperty.fromExpression('0'))
937        context = QgsRenderContext()
938        f.updateDataDefinedProperties(context)
939        self.assertFalse(f.mask().enabled())
940
941        # mask buffer size
942        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.MaskBufferSize, QgsProperty.fromExpression('7.8'))
943        f.updateDataDefinedProperties(context)
944        self.assertEqual(f.mask().size(), 7.8)
945        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.MaskBufferUnit, QgsProperty.fromExpression("'pixel'"))
946        f.updateDataDefinedProperties(context)
947        self.assertEqual(f.mask().sizeUnit(), QgsUnitTypes.RenderPixels)
948
949        # mask opacity
950        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.MaskOpacity, QgsProperty.fromExpression('37'))
951        f.updateDataDefinedProperties(context)
952        self.assertEqual(f.mask().opacity(), 0.37)
953
954        # join style
955        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.MaskJoinStyle, QgsProperty.fromExpression("'miter'"))
956        f.updateDataDefinedProperties(context)
957        self.assertEqual(f.mask().joinStyle(), Qt.MiterJoin)
958
959    def testDataDefinedBackgroundSettings(self):
960        f = QgsTextFormat()
961        context = QgsRenderContext()
962
963        # background enabled
964        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShapeDraw, QgsProperty.fromExpression('1'))
965        f.updateDataDefinedProperties(context)
966        self.assertTrue(f.background().enabled())
967        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShapeDraw, QgsProperty.fromExpression('0'))
968        context = QgsRenderContext()
969        f.updateDataDefinedProperties(context)
970        self.assertFalse(f.background().enabled())
971
972        # background size
973        f.background().setSize(QSizeF(13, 14))
974        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShapeSizeX, QgsProperty.fromExpression('7.8'))
975        f.updateDataDefinedProperties(context)
976        self.assertEqual(f.background().size().width(), 7.8)
977        self.assertEqual(f.background().size().height(), 14)
978        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShapeSizeY, QgsProperty.fromExpression('17.8'))
979        f.updateDataDefinedProperties(context)
980        self.assertEqual(f.background().size().width(), 7.8)
981        self.assertEqual(f.background().size().height(), 17.8)
982
983        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShapeSizeUnits, QgsProperty.fromExpression("'pixel'"))
984        f.updateDataDefinedProperties(context)
985        self.assertEqual(f.background().sizeUnit(), QgsUnitTypes.RenderPixels)
986
987        # shape kind
988        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShapeKind, QgsProperty.fromExpression("'square'"))
989        f.updateDataDefinedProperties(context)
990        self.assertEqual(f.background().type(), QgsTextBackgroundSettings.ShapeSquare)
991        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShapeKind, QgsProperty.fromExpression("'ellipse'"))
992        f.updateDataDefinedProperties(context)
993        self.assertEqual(f.background().type(), QgsTextBackgroundSettings.ShapeEllipse)
994        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShapeKind, QgsProperty.fromExpression("'circle'"))
995        f.updateDataDefinedProperties(context)
996        self.assertEqual(f.background().type(), QgsTextBackgroundSettings.ShapeCircle)
997        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShapeKind, QgsProperty.fromExpression("'svg'"))
998        f.updateDataDefinedProperties(context)
999        self.assertEqual(f.background().type(), QgsTextBackgroundSettings.ShapeSVG)
1000        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShapeKind, QgsProperty.fromExpression("'marker'"))
1001        f.updateDataDefinedProperties(context)
1002        self.assertEqual(f.background().type(), QgsTextBackgroundSettings.ShapeMarkerSymbol)
1003        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShapeKind, QgsProperty.fromExpression("'rect'"))
1004        f.updateDataDefinedProperties(context)
1005        self.assertEqual(f.background().type(), QgsTextBackgroundSettings.ShapeRectangle)
1006
1007        # size type
1008        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShapeSizeType, QgsProperty.fromExpression("'fixed'"))
1009        f.updateDataDefinedProperties(context)
1010        self.assertEqual(f.background().sizeType(), QgsTextBackgroundSettings.SizeFixed)
1011        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShapeSizeType, QgsProperty.fromExpression("'buffer'"))
1012        f.updateDataDefinedProperties(context)
1013        self.assertEqual(f.background().sizeType(), QgsTextBackgroundSettings.SizeBuffer)
1014
1015        # svg path
1016        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShapeSVGFile, QgsProperty.fromExpression("'my.svg'"))
1017        f.updateDataDefinedProperties(context)
1018        self.assertEqual(f.background().svgFile(), 'my.svg')
1019
1020        # shape rotation
1021        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShapeRotation, QgsProperty.fromExpression('67'))
1022        f.updateDataDefinedProperties(context)
1023        self.assertEqual(f.background().rotation(), 67)
1024        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShapeRotationType,
1025                                              QgsProperty.fromExpression("'offset'"))
1026        f.updateDataDefinedProperties(context)
1027        self.assertEqual(f.background().rotationType(), QgsTextBackgroundSettings.RotationOffset)
1028        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShapeRotationType,
1029                                              QgsProperty.fromExpression("'fixed'"))
1030        f.updateDataDefinedProperties(context)
1031        self.assertEqual(f.background().rotationType(), QgsTextBackgroundSettings.RotationFixed)
1032        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShapeRotationType,
1033                                              QgsProperty.fromExpression("'sync'"))
1034        f.updateDataDefinedProperties(context)
1035        self.assertEqual(f.background().rotationType(), QgsTextBackgroundSettings.RotationSync)
1036
1037        # shape offset
1038        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShapeOffset, QgsProperty.fromExpression("'7,9'"))
1039        f.updateDataDefinedProperties(context)
1040        self.assertEqual(f.background().offset(), QPointF(7, 9))
1041        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShapeOffsetUnits,
1042                                              QgsProperty.fromExpression("'pixel'"))
1043        f.updateDataDefinedProperties(context)
1044        self.assertEqual(f.background().offsetUnit(), QgsUnitTypes.RenderPixels)
1045
1046        # shape radii
1047        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShapeRadii, QgsProperty.fromExpression("'18,19'"))
1048        f.updateDataDefinedProperties(context)
1049        self.assertEqual(f.background().radii(), QSizeF(18, 19))
1050        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShapeRadiiUnits,
1051                                              QgsProperty.fromExpression("'pixel'"))
1052        f.updateDataDefinedProperties(context)
1053        self.assertEqual(f.background().radiiUnit(), QgsUnitTypes.RenderPixels)
1054
1055        # shape opacity
1056        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShapeOpacity, QgsProperty.fromExpression('37'))
1057        f.updateDataDefinedProperties(context)
1058        self.assertEqual(f.background().opacity(), 0.37)
1059
1060        # color
1061        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShapeFillColor,
1062                                              QgsProperty.fromExpression("'#ff0088'"))
1063        f.updateDataDefinedProperties(context)
1064        self.assertEqual(f.background().fillColor().name(), '#ff0088')
1065        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShapeStrokeColor,
1066                                              QgsProperty.fromExpression("'#8800ff'"))
1067        f.updateDataDefinedProperties(context)
1068        self.assertEqual(f.background().strokeColor().name(), '#8800ff')
1069
1070        # stroke width
1071        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShapeStrokeWidth, QgsProperty.fromExpression('88'))
1072        f.updateDataDefinedProperties(context)
1073        self.assertEqual(f.background().strokeWidth(), 88)
1074        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShapeStrokeWidthUnits,
1075                                              QgsProperty.fromExpression("'pixel'"))
1076        f.updateDataDefinedProperties(context)
1077        self.assertEqual(f.background().strokeWidthUnit(), QgsUnitTypes.RenderPixels)
1078
1079        # blend mode
1080        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShapeBlendMode, QgsProperty.fromExpression("'burn'"))
1081        f.updateDataDefinedProperties(context)
1082        self.assertEqual(f.background().blendMode(), QPainter.CompositionMode_ColorBurn)
1083
1084        # join style
1085        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShapeJoinStyle, QgsProperty.fromExpression("'miter'"))
1086        f.updateDataDefinedProperties(context)
1087        self.assertEqual(f.background().joinStyle(), Qt.MiterJoin)
1088
1089    def testDataDefinedShadowSettings(self):
1090        f = QgsTextFormat()
1091        context = QgsRenderContext()
1092
1093        # shadow enabled
1094        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShadowDraw, QgsProperty.fromExpression('1'))
1095        f.updateDataDefinedProperties(context)
1096        self.assertTrue(f.shadow().enabled())
1097        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShadowDraw, QgsProperty.fromExpression('0'))
1098        context = QgsRenderContext()
1099        f.updateDataDefinedProperties(context)
1100        self.assertFalse(f.shadow().enabled())
1101
1102        # placement type
1103        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShadowUnder, QgsProperty.fromExpression("'text'"))
1104        f.updateDataDefinedProperties(context)
1105        self.assertEqual(f.shadow().shadowPlacement(), QgsTextShadowSettings.ShadowText)
1106        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShadowUnder, QgsProperty.fromExpression("'buffer'"))
1107        f.updateDataDefinedProperties(context)
1108        self.assertEqual(f.shadow().shadowPlacement(), QgsTextShadowSettings.ShadowBuffer)
1109        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShadowUnder,
1110                                              QgsProperty.fromExpression("'background'"))
1111        f.updateDataDefinedProperties(context)
1112        self.assertEqual(f.shadow().shadowPlacement(), QgsTextShadowSettings.ShadowShape)
1113        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShadowUnder, QgsProperty.fromExpression("'svg'"))
1114        f.updateDataDefinedProperties(context)
1115        self.assertEqual(f.shadow().shadowPlacement(), QgsTextShadowSettings.ShadowLowest)
1116        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShadowUnder, QgsProperty.fromExpression("'lowest'"))
1117
1118        # offset angle
1119        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShadowOffsetAngle, QgsProperty.fromExpression('67'))
1120        f.updateDataDefinedProperties(context)
1121        self.assertEqual(f.shadow().offsetAngle(), 67)
1122
1123        # offset distance
1124        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShadowOffsetDist, QgsProperty.fromExpression('38'))
1125        f.updateDataDefinedProperties(context)
1126        self.assertEqual(f.shadow().offsetDistance(), 38)
1127        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShadowOffsetUnits,
1128                                              QgsProperty.fromExpression("'pixel'"))
1129        f.updateDataDefinedProperties(context)
1130        self.assertEqual(f.shadow().offsetUnit(), QgsUnitTypes.RenderPixels)
1131
1132        # radius
1133        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShadowRadius, QgsProperty.fromExpression('58'))
1134        f.updateDataDefinedProperties(context)
1135        self.assertEqual(f.shadow().blurRadius(), 58)
1136        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShadowRadiusUnits,
1137                                              QgsProperty.fromExpression("'pixel'"))
1138        f.updateDataDefinedProperties(context)
1139        self.assertEqual(f.shadow().blurRadiusUnit(), QgsUnitTypes.RenderPixels)
1140
1141        # opacity
1142        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShadowOpacity, QgsProperty.fromExpression('37'))
1143        f.updateDataDefinedProperties(context)
1144        self.assertEqual(f.shadow().opacity(), 0.37)
1145
1146        # color
1147        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShadowColor, QgsProperty.fromExpression("'#ff0088'"))
1148        f.updateDataDefinedProperties(context)
1149        self.assertEqual(f.shadow().color().name(), '#ff0088')
1150
1151        # blend mode
1152        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.ShadowBlendMode, QgsProperty.fromExpression("'burn'"))
1153        f.updateDataDefinedProperties(context)
1154        self.assertEqual(f.shadow().blendMode(), QPainter.CompositionMode_ColorBurn)
1155
1156    def testDataDefinedFormatSettings(self):
1157        f = QgsTextFormat()
1158        font = f.font()
1159        font.setUnderline(True)
1160        font.setStrikeOut(True)
1161        font.setWordSpacing(5.7)
1162        font.setLetterSpacing(QFont.AbsoluteSpacing, 3.3)
1163        f.setFont(font)
1164        context = QgsRenderContext()
1165
1166        # family
1167        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.Family, QgsProperty.fromExpression(
1168            "'{}'".format(QgsFontUtils.getStandardTestFont().family())))
1169        f.updateDataDefinedProperties(context)
1170        self.assertEqual(f.font().family(), QgsFontUtils.getStandardTestFont().family())
1171
1172        # style
1173        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.FontStyle, QgsProperty.fromExpression("'Bold'"))
1174        f.updateDataDefinedProperties(context)
1175        self.assertEqual(f.font().styleName(), 'Bold')
1176        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.FontStyle, QgsProperty.fromExpression("'Roman'"))
1177        f.updateDataDefinedProperties(context)
1178        self.assertEqual(f.font().styleName(), 'Roman')
1179        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.Bold, QgsProperty.fromExpression("1"))
1180        f.updateDataDefinedProperties(context)
1181        self.assertTrue(f.font().bold())
1182        self.assertFalse(f.font().italic())
1183        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.Bold, QgsProperty.fromExpression("0"))
1184        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.Italic, QgsProperty.fromExpression("1"))
1185        f.updateDataDefinedProperties(context)
1186        self.assertFalse(f.font().bold())
1187        self.assertTrue(f.font().italic())
1188        self.assertTrue(f.font().underline())
1189        self.assertTrue(f.font().strikeOut())
1190        self.assertAlmostEqual(f.font().wordSpacing(), 5.7, 1)
1191        self.assertAlmostEqual(f.font().letterSpacing(), 3.3, 1)
1192
1193        # underline
1194        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.Underline, QgsProperty.fromExpression("0"))
1195        f.updateDataDefinedProperties(context)
1196        self.assertFalse(f.font().underline())
1197        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.Underline, QgsProperty.fromExpression("1"))
1198        f.updateDataDefinedProperties(context)
1199        self.assertTrue(f.font().underline())
1200
1201        # strikeout
1202        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.Strikeout, QgsProperty.fromExpression("0"))
1203        f.updateDataDefinedProperties(context)
1204        self.assertFalse(f.font().strikeOut())
1205        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.Strikeout, QgsProperty.fromExpression("1"))
1206        f.updateDataDefinedProperties(context)
1207        self.assertTrue(f.font().strikeOut())
1208
1209        # color
1210        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.Color, QgsProperty.fromExpression("'#ff0088'"))
1211        f.updateDataDefinedProperties(context)
1212        self.assertEqual(f.color().name(), '#ff0088')
1213
1214        # size
1215        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.Size, QgsProperty.fromExpression('38'))
1216        f.updateDataDefinedProperties(context)
1217        self.assertEqual(f.size(), 38)
1218        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.FontSizeUnit, QgsProperty.fromExpression("'pixel'"))
1219        f.updateDataDefinedProperties(context)
1220        self.assertEqual(f.sizeUnit(), QgsUnitTypes.RenderPixels)
1221
1222        # opacity
1223        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.FontOpacity, QgsProperty.fromExpression('37'))
1224        f.updateDataDefinedProperties(context)
1225        self.assertEqual(f.opacity(), 0.37)
1226
1227        # letter spacing
1228        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.FontLetterSpacing, QgsProperty.fromExpression('58'))
1229        f.updateDataDefinedProperties(context)
1230        self.assertEqual(f.font().letterSpacing(), 58)
1231
1232        # word spacing
1233        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.FontWordSpacing, QgsProperty.fromExpression('8'))
1234        f.updateDataDefinedProperties(context)
1235        self.assertEqual(f.font().wordSpacing(), 8)
1236
1237        # blend mode
1238        f.dataDefinedProperties().setProperty(QgsPalLayerSettings.FontBlendMode, QgsProperty.fromExpression("'burn'"))
1239        f.updateDataDefinedProperties(context)
1240        self.assertEqual(f.blendMode(), QPainter.CompositionMode_ColorBurn)
1241
1242    def testFontFoundFromLayer(self):
1243        layer = createEmptyLayer()
1244        layer.setCustomProperty('labeling/fontFamily', 'asdasd')
1245        f = QgsTextFormat()
1246        f.readFromLayer(layer)
1247        self.assertFalse(f.fontFound())
1248
1249        font = getTestFont()
1250        layer.setCustomProperty('labeling/fontFamily', font.family())
1251        f.readFromLayer(layer)
1252        self.assertTrue(f.fontFound())
1253
1254    def testFontFoundFromXml(self):
1255        doc = QDomDocument("testdoc")
1256        f = QgsTextFormat()
1257        elem = f.writeXml(doc, QgsReadWriteContext())
1258        elem.setAttribute('fontFamily', 'asdfasdfsadf')
1259        parent = doc.createElement("parent")
1260        parent.appendChild(elem)
1261
1262        f.readXml(parent, QgsReadWriteContext())
1263        self.assertFalse(f.fontFound())
1264
1265        font = getTestFont()
1266        elem.setAttribute('fontFamily', font.family())
1267        f.readXml(parent, QgsReadWriteContext())
1268        self.assertTrue(f.fontFound())
1269
1270    def testFromQFont(self):
1271        qfont = getTestFont()
1272        qfont.setPointSizeF(16.5)
1273        qfont.setLetterSpacing(QFont.AbsoluteSpacing, 3)
1274
1275        format = QgsTextFormat.fromQFont(qfont)
1276        self.assertEqual(format.font().family(), qfont.family())
1277        self.assertEqual(format.font().letterSpacing(), 3.0)
1278        self.assertEqual(format.size(), 16.5)
1279        self.assertEqual(format.sizeUnit(), QgsUnitTypes.RenderPoints)
1280
1281        qfont.setPixelSize(12)
1282        format = QgsTextFormat.fromQFont(qfont)
1283        self.assertEqual(format.size(), 12.0)
1284        self.assertEqual(format.sizeUnit(), QgsUnitTypes.RenderPixels)
1285
1286    def testToQFont(self):
1287        s = QgsTextFormat()
1288        f = getTestFont()
1289        f.setLetterSpacing(QFont.AbsoluteSpacing, 3)
1290        s.setFont(f)
1291        s.setNamedStyle('Italic')
1292        s.setSize(5.5)
1293        s.setSizeUnit(QgsUnitTypes.RenderPoints)
1294
1295        qfont = s.toQFont()
1296        self.assertEqual(qfont.family(), f.family())
1297        self.assertEqual(qfont.pointSizeF(), 5.5)
1298        self.assertEqual(qfont.letterSpacing(), 3.0)
1299
1300        s.setSize(5)
1301        s.setSizeUnit(QgsUnitTypes.RenderPixels)
1302        qfont = s.toQFont()
1303        self.assertEqual(qfont.pixelSize(), 5)
1304
1305        s.setSize(5)
1306        s.setSizeUnit(QgsUnitTypes.RenderMillimeters)
1307        qfont = s.toQFont()
1308        self.assertAlmostEqual(qfont.pointSizeF(), 14.17, 2)
1309
1310        s.setSizeUnit(QgsUnitTypes.RenderInches)
1311        qfont = s.toQFont()
1312        self.assertAlmostEqual(qfont.pointSizeF(), 360.0, 2)
1313
1314    def testFontMetrics(self):
1315        """
1316        Test calculating font metrics from scaled text formats
1317        """
1318        s = QgsTextFormat()
1319        f = getTestFont()
1320        s.setFont(f)
1321        s.setSize(12)
1322        s.setSizeUnit(QgsUnitTypes.RenderPoints)
1323
1324        string = 'xxxxxxxxxxxxxxxxxxxxxx'
1325
1326        image = QImage(400, 400, QImage.Format_RGB32)
1327        painter = QPainter(image)
1328        context = QgsRenderContext.fromQPainter(painter)
1329        context.setScaleFactor(1)
1330        metrics = QgsTextRenderer.fontMetrics(context, s)
1331        context.setScaleFactor(2)
1332        metrics2 = QgsTextRenderer.fontMetrics(context, s)
1333        painter.end()
1334
1335        self.assertAlmostEqual(metrics.width(string), 51.9, 1)
1336        self.assertAlmostEqual(metrics2.width(string), 104.15, 1)
1337
1338    def imageCheck(self, name, reference_image, image):
1339        PyQgsTextRenderer.report += "<h2>Render {}</h2>\n".format(name)
1340        temp_dir = QDir.tempPath() + '/'
1341        file_name = temp_dir + name + ".png"
1342        image.save(file_name, "PNG")
1343        checker = QgsRenderChecker()
1344        checker.setControlPathPrefix("text_renderer")
1345        checker.setControlName(reference_image)
1346        checker.setRenderedImage(file_name)
1347        checker.setColorTolerance(2)
1348        result = checker.compareImages(name, 20)
1349        PyQgsTextRenderer.report += checker.report()
1350        print(checker.report())
1351        return result
1352
1353    def checkRender(self, format, name, part=None, angle=0, alignment=QgsTextRenderer.AlignLeft,
1354                    text=['test'],
1355                    rect=QRectF(100, 100, 50, 250),
1356                    vAlignment=QgsTextRenderer.AlignTop):
1357
1358        image = QImage(400, 400, QImage.Format_RGB32)
1359
1360        painter = QPainter()
1361        ms = QgsMapSettings()
1362        ms.setExtent(QgsRectangle(0, 0, 50, 50))
1363        ms.setOutputSize(image.size())
1364        context = QgsRenderContext.fromMapSettings(ms)
1365        context.setPainter(painter)
1366        context.setScaleFactor(96 / 25.4)  # 96 DPI
1367        context.setFlag(QgsRenderContext.ApplyScalingWorkaroundForTextRendering, True)
1368
1369        painter.begin(image)
1370        painter.setRenderHint(QPainter.Antialiasing)
1371        image.fill(QColor(152, 219, 249))
1372
1373        painter.setBrush(QBrush(QColor(182, 239, 255)))
1374        painter.setPen(Qt.NoPen)
1375        # to highlight rect on image
1376        # painter.drawRect(rect)
1377
1378        if part is not None:
1379            QgsTextRenderer.drawPart(rect,
1380                                     angle,
1381                                     alignment,
1382                                     text,
1383                                     context,
1384                                     format,
1385                                     part)
1386        else:
1387            QgsTextRenderer.drawText(rect,
1388                                     angle,
1389                                     alignment,
1390                                     text,
1391                                     context,
1392                                     format, vAlignment=vAlignment)
1393
1394        painter.setFont(format.scaledFont(context))
1395        painter.setPen(QPen(QColor(255, 0, 255, 200)))
1396        # For comparison with QPainter's methods:
1397        # if alignment == QgsTextRenderer.AlignCenter:
1398        #     align = Qt.AlignHCenter
1399        # elif alignment == QgsTextRenderer.AlignRight:
1400        #     align = Qt.AlignRight
1401        # else:
1402        #     align = Qt.AlignLeft
1403        # painter.drawText(rect, align, '\n'.join(text))
1404
1405        painter.end()
1406        return self.imageCheck(name, name, image)
1407
1408    def checkRenderPoint(self, format, name, part=None, angle=0, alignment=QgsTextRenderer.AlignLeft,
1409                         text=['test'],
1410                         point=QPointF(100, 200)):
1411        image = QImage(400, 400, QImage.Format_RGB32)
1412
1413        painter = QPainter()
1414        ms = QgsMapSettings()
1415        ms.setExtent(QgsRectangle(0, 0, 50, 50))
1416        ms.setOutputSize(image.size())
1417        context = QgsRenderContext.fromMapSettings(ms)
1418        context.setPainter(painter)
1419        context.setScaleFactor(96 / 25.4)  # 96 DPI
1420
1421        painter.begin(image)
1422        painter.setRenderHint(QPainter.Antialiasing)
1423        image.fill(QColor(152, 219, 249))
1424
1425        painter.setBrush(QBrush(QColor(182, 239, 255)))
1426        painter.setPen(Qt.NoPen)
1427        # to highlight point on image
1428        # painter.drawRect(QRectF(point.x() - 5, point.y() - 5, 10, 10))
1429
1430        if part is not None:
1431            QgsTextRenderer.drawPart(point,
1432                                     angle,
1433                                     alignment,
1434                                     text,
1435                                     context,
1436                                     format,
1437                                     part)
1438        else:
1439            QgsTextRenderer.drawText(point,
1440                                     angle,
1441                                     alignment,
1442                                     text,
1443                                     context,
1444                                     format)
1445
1446        painter.setFont(format.scaledFont(context))
1447        painter.setPen(QPen(QColor(255, 0, 255, 200)))
1448        # For comparison with QPainter's methods:
1449        # painter.drawText(point, '\n'.join(text))
1450
1451        painter.end()
1452        return self.imageCheck(name, name, image)
1453
1454    def testDrawBackgroundDisabled(self):
1455        format = QgsTextFormat()
1456        format.setFont(getTestFont('bold'))
1457        format.background().setEnabled(False)
1458        assert self.checkRender(format, 'background_disabled', QgsTextRenderer.Background)
1459
1460    def testDrawBackgroundRectangleFixedSizeMapUnits(self):
1461        format = QgsTextFormat()
1462        format.setFont(getTestFont('bold'))
1463        format.background().setEnabled(True)
1464        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1465        format.background().setSize(QSizeF(20, 10))
1466        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
1467        format.background().setSizeUnit(QgsUnitTypes.RenderMapUnits)
1468        assert self.checkRender(format, 'background_rect_mapunits', QgsTextRenderer.Background)
1469
1470    def testDrawBackgroundRectangleFixedSizeWithRotatedText(self):
1471        format = QgsTextFormat()
1472        format.setFont(getTestFont('bold'))
1473        format.setSize(40)
1474        format.background().setEnabled(True)
1475        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1476        format.background().setSize(QSizeF(20, 20))
1477        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
1478        format.background().setSizeUnit(QgsUnitTypes.RenderMillimeters)
1479        assert self.checkRenderPoint(format, 'background_rect_fixed_rotated_text', angle=3.141 / 4)
1480
1481    def testDrawBackgroundRectangleBufferSizeWithRotatedText(self):
1482        format = QgsTextFormat()
1483        format.setFont(getTestFont('bold'))
1484        format.setSize(40)
1485        format.background().setEnabled(True)
1486        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1487        format.background().setSize(QSizeF(2, 3))
1488        format.background().setSizeType(QgsTextBackgroundSettings.SizeBuffer)
1489        format.background().setSizeUnit(QgsUnitTypes.RenderMillimeters)
1490        assert self.checkRenderPoint(format, 'background_rect_buffer_rotated_text', angle=3.141 / 4)
1491
1492    def testDrawBackgroundRectangleMultilineFixedSizeMapUnits(self):
1493        format = QgsTextFormat()
1494        format.setFont(getTestFont('bold'))
1495        format.background().setEnabled(True)
1496        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1497        format.background().setSize(QSizeF(20, 10))
1498        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
1499        format.background().setSizeUnit(QgsUnitTypes.RenderMapUnits)
1500        assert self.checkRender(format, 'background_rect_multiline_mapunits', QgsTextRenderer.Background,
1501                                text=['test', 'multi', 'line'])
1502
1503    def testDrawBackgroundPointMultilineFixedSizeMapUnits(self):
1504        format = QgsTextFormat()
1505        format.setFont(getTestFont('bold'))
1506        format.background().setEnabled(True)
1507        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1508        format.background().setSize(QSizeF(20, 10))
1509        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
1510        format.background().setSizeUnit(QgsUnitTypes.RenderMapUnits)
1511        assert self.checkRenderPoint(format, 'background_point_multiline_mapunits', QgsTextRenderer.Background,
1512                                     text=['test', 'multi', 'line'])
1513
1514    def testDrawBackgroundRectangleMultilineBufferMapUnits(self):
1515        format = QgsTextFormat()
1516        format.setFont(getTestFont('bold'))
1517        format.background().setEnabled(True)
1518        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1519        format.background().setSize(QSizeF(4, 2))
1520        format.background().setSizeType(QgsTextBackgroundSettings.SizeBuffer)
1521        format.background().setSizeUnit(QgsUnitTypes.RenderMapUnits)
1522        assert self.checkRender(format, 'background_rect_multiline_buffer_mapunits', QgsTextRenderer.Background,
1523                                text=['test', 'multi', 'line'])
1524
1525    def testDrawBackgroundPointMultilineBufferMapUnits(self):
1526        format = QgsTextFormat()
1527        format.setFont(getTestFont('bold'))
1528        format.background().setEnabled(True)
1529        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1530        format.background().setSize(QSizeF(4, 2))
1531        format.background().setSizeType(QgsTextBackgroundSettings.SizeBuffer)
1532        format.background().setSizeUnit(QgsUnitTypes.RenderMapUnits)
1533        assert self.checkRenderPoint(format, 'background_point_multiline_buffer_mapunits', QgsTextRenderer.Background,
1534                                     text=['test', 'multi', 'line'])
1535
1536    def testDrawBackgroundPointFixedSizeMapUnits(self):
1537        format = QgsTextFormat()
1538        format.setFont(getTestFont('bold'))
1539        format.background().setEnabled(True)
1540        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1541        format.background().setSize(QSizeF(20, 10))
1542        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
1543        format.background().setSizeUnit(QgsUnitTypes.RenderMapUnits)
1544        assert self.checkRenderPoint(format, 'background_point_mapunits', QgsTextRenderer.Background,
1545                                     text=['Testy'])
1546
1547    def testDrawBackgroundRectangleCenterAlignFixedSizeMapUnits(self):
1548        format = QgsTextFormat()
1549        format.setFont(getTestFont('bold'))
1550        format.background().setEnabled(True)
1551        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1552        format.background().setSize(QSizeF(20, 10))
1553        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
1554        format.background().setSizeUnit(QgsUnitTypes.RenderMapUnits)
1555        assert self.checkRender(format, 'background_rect_center_mapunits', QgsTextRenderer.Background,
1556                                alignment=QgsTextRenderer.AlignCenter)
1557
1558    def testDrawBackgroundPointCenterAlignFixedSizeMapUnits(self):
1559        format = QgsTextFormat()
1560        format.setFont(getTestFont('bold'))
1561        format.background().setEnabled(True)
1562        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1563        format.background().setSize(QSizeF(20, 10))
1564        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
1565        format.background().setSizeUnit(QgsUnitTypes.RenderMapUnits)
1566        assert self.checkRenderPoint(format, 'background_point_center_mapunits', QgsTextRenderer.Background,
1567                                     alignment=QgsTextRenderer.AlignCenter)
1568
1569    def testDrawBackgroundRectangleRightAlignFixedSizeMapUnits(self):
1570        format = QgsTextFormat()
1571        format.setFont(getTestFont('bold'))
1572        format.background().setEnabled(True)
1573        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1574        format.background().setSize(QSizeF(20, 10))
1575        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
1576        format.background().setSizeUnit(QgsUnitTypes.RenderMapUnits)
1577        assert self.checkRender(format, 'background_rect_right_mapunits', QgsTextRenderer.Background,
1578                                alignment=QgsTextRenderer.AlignRight)
1579
1580    def testDrawBackgroundPointRightAlignFixedSizeMapUnits(self):
1581        format = QgsTextFormat()
1582        format.setFont(getTestFont('bold'))
1583        format.background().setEnabled(True)
1584        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1585        format.background().setSize(QSizeF(20, 10))
1586        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
1587        format.background().setSizeUnit(QgsUnitTypes.RenderMapUnits)
1588        assert self.checkRenderPoint(format, 'background_point_right_mapunits', QgsTextRenderer.Background,
1589                                     alignment=QgsTextRenderer.AlignRight)
1590
1591    def testDrawBackgroundRectangleFixedSizeMM(self):
1592        format = QgsTextFormat()
1593        format.setFont(getTestFont('bold'))
1594        format.background().setEnabled(True)
1595        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1596        format.background().setSize(QSizeF(30, 20))
1597        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
1598        format.background().setSizeUnit(QgsUnitTypes.RenderMillimeters)
1599        assert self.checkRender(format, 'background_rect_mm', QgsTextRenderer.Background)
1600
1601    def testDrawBackgroundRectangleFixedSizePixels(self):
1602        format = QgsTextFormat()
1603        format.setFont(getTestFont('bold'))
1604        format.background().setEnabled(True)
1605        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1606        format.background().setSize(QSizeF(60, 80))
1607        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
1608        format.background().setSizeUnit(QgsUnitTypes.RenderPixels)
1609        assert self.checkRender(format, 'background_rect_pixels', QgsTextRenderer.Background)
1610
1611    def testDrawBackgroundRectBufferPixels(self):
1612        format = QgsTextFormat()
1613        format.setFont(getTestFont('bold'))
1614        format.background().setEnabled(True)
1615        svg = os.path.join(
1616            svgSymbolsPath(), 'backgrounds', 'background_square.svg')
1617        format.background().setSvgFile(svg)
1618        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1619        format.background().setSize(QSizeF(30, 50))
1620        format.background().setSizeType(QgsTextBackgroundSettings.SizeBuffer)
1621        format.background().setSizeUnit(QgsUnitTypes.RenderPixels)
1622        assert self.checkRender(format, 'background_rect_buffer_pixels', QgsTextRenderer.Background,
1623                                rect=QRectF(100, 100, 100, 100))
1624
1625    def testDrawBackgroundRectRightAlignBufferPixels(self):
1626        format = QgsTextFormat()
1627        format.setFont(getTestFont('bold'))
1628        format.background().setEnabled(True)
1629        svg = os.path.join(
1630            svgSymbolsPath(), 'backgrounds', 'background_square.svg')
1631        format.background().setSvgFile(svg)
1632        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1633        format.background().setSize(QSizeF(30, 50))
1634        format.background().setSizeType(QgsTextBackgroundSettings.SizeBuffer)
1635        format.background().setSizeUnit(QgsUnitTypes.RenderPixels)
1636        assert self.checkRender(format, 'background_rect_right_buffer_pixels', QgsTextRenderer.Background,
1637                                alignment=QgsTextRenderer.AlignRight,
1638                                rect=QRectF(100, 100, 100, 100))
1639
1640    def testDrawBackgroundRectCenterAlignBufferPixels(self):
1641        format = QgsTextFormat()
1642        format.setFont(getTestFont('bold'))
1643        format.background().setEnabled(True)
1644        svg = os.path.join(
1645            svgSymbolsPath(), 'backgrounds', 'background_square.svg')
1646        format.background().setSvgFile(svg)
1647        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1648        format.background().setSize(QSizeF(30, 50))
1649        format.background().setSizeType(QgsTextBackgroundSettings.SizeBuffer)
1650        format.background().setSizeUnit(QgsUnitTypes.RenderPixels)
1651        assert self.checkRender(format, 'background_rect_center_buffer_pixels', QgsTextRenderer.Background,
1652                                alignment=QgsTextRenderer.AlignCenter,
1653                                rect=QRectF(100, 100, 100, 100))
1654
1655    def testDrawBackgroundPointBufferPixels(self):
1656        format = QgsTextFormat()
1657        format.setFont(getTestFont('bold'))
1658        format.background().setEnabled(True)
1659        svg = os.path.join(
1660            svgSymbolsPath(), 'backgrounds', 'background_square.svg')
1661        format.background().setSvgFile(svg)
1662        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1663        format.background().setSize(QSizeF(30, 50))
1664        format.background().setSizeType(QgsTextBackgroundSettings.SizeBuffer)
1665        format.background().setSizeUnit(QgsUnitTypes.RenderPixels)
1666        assert self.checkRenderPoint(format, 'background_point_buffer_pixels', QgsTextRenderer.Background,
1667                                     point=QPointF(100, 100))
1668
1669    def testDrawBackgroundPointRightAlignBufferPixels(self):
1670        format = QgsTextFormat()
1671        format.setFont(getTestFont('bold'))
1672        format.background().setEnabled(True)
1673        svg = os.path.join(
1674            svgSymbolsPath(), 'backgrounds', 'background_square.svg')
1675        format.background().setSvgFile(svg)
1676        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1677        format.background().setSize(QSizeF(30, 50))
1678        format.background().setSizeType(QgsTextBackgroundSettings.SizeBuffer)
1679        format.background().setSizeUnit(QgsUnitTypes.RenderPixels)
1680        assert self.checkRenderPoint(format, 'background_point_right_buffer_pixels', QgsTextRenderer.Background,
1681                                     alignment=QgsTextRenderer.AlignRight,
1682                                     point=QPointF(100, 100))
1683
1684    def testDrawBackgroundPointCenterAlignBufferPixels(self):
1685        format = QgsTextFormat()
1686        format.setFont(getTestFont('bold'))
1687        format.background().setEnabled(True)
1688        svg = os.path.join(
1689            svgSymbolsPath(), 'backgrounds', 'background_square.svg')
1690        format.background().setSvgFile(svg)
1691        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1692        format.background().setSize(QSizeF(30, 50))
1693        format.background().setSizeType(QgsTextBackgroundSettings.SizeBuffer)
1694        format.background().setSizeUnit(QgsUnitTypes.RenderPixels)
1695        assert self.checkRenderPoint(format, 'background_point_center_buffer_pixels', QgsTextRenderer.Background,
1696                                     alignment=QgsTextRenderer.AlignCenter,
1697                                     point=QPointF(100, 100))
1698
1699    def testDrawBackgroundRectBufferMapUnits(self):
1700        format = QgsTextFormat()
1701        format.setFont(getTestFont('bold'))
1702        format.background().setEnabled(True)
1703        svg = os.path.join(
1704            svgSymbolsPath(), 'backgrounds', 'background_square.svg')
1705        format.background().setSvgFile(svg)
1706        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1707        format.background().setSize(QSizeF(4, 6))
1708        format.background().setSizeType(QgsTextBackgroundSettings.SizeBuffer)
1709        format.background().setSizeUnit(QgsUnitTypes.RenderMapUnits)
1710        assert self.checkRender(format, 'background_rect_buffer_mapunits', QgsTextRenderer.Background,
1711                                rect=QRectF(100, 100, 100, 100))
1712
1713    def testDrawBackgroundRectBufferMM(self):
1714        format = QgsTextFormat()
1715        format.setFont(getTestFont('bold'))
1716        format.background().setEnabled(True)
1717        svg = os.path.join(
1718            svgSymbolsPath(), 'backgrounds', 'background_square.svg')
1719        format.background().setSvgFile(svg)
1720        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1721        format.background().setSize(QSizeF(10, 16))
1722        format.background().setSizeType(QgsTextBackgroundSettings.SizeBuffer)
1723        format.background().setSizeUnit(QgsUnitTypes.RenderMillimeters)
1724        assert self.checkRender(format, 'background_rect_buffer_mm', QgsTextRenderer.Background,
1725                                rect=QRectF(100, 100, 100, 100))
1726
1727    def testDrawBackgroundEllipse(self):
1728        format = QgsTextFormat()
1729        format.setFont(getTestFont('bold'))
1730        format.background().setEnabled(True)
1731        format.background().setType(QgsTextBackgroundSettings.ShapeEllipse)
1732        format.background().setSize(QSizeF(60, 80))
1733        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
1734        format.background().setSizeUnit(QgsUnitTypes.RenderPixels)
1735        assert self.checkRender(format, 'background_ellipse_pixels', QgsTextRenderer.Background)
1736
1737    def testDrawBackgroundSvgFixedPixels(self):
1738        format = QgsTextFormat()
1739        format.setFont(getTestFont('bold'))
1740        format.background().setEnabled(True)
1741        svg = os.path.join(
1742            svgSymbolsPath(), 'backgrounds', 'background_square.svg')
1743        format.background().setSvgFile(svg)
1744        format.background().setType(QgsTextBackgroundSettings.ShapeSVG)
1745        format.background().setSize(QSizeF(60, 80))
1746        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
1747        format.background().setSizeUnit(QgsUnitTypes.RenderPixels)
1748        assert self.checkRender(format, 'background_svg_fixed_pixels', QgsTextRenderer.Background)
1749
1750    def testDrawBackgroundSvgFixedMapUnits(self):
1751        format = QgsTextFormat()
1752        format.setFont(getTestFont('bold'))
1753        format.background().setEnabled(True)
1754        svg = os.path.join(
1755            svgSymbolsPath(), 'backgrounds', 'background_square.svg')
1756        format.background().setSvgFile(svg)
1757        format.background().setType(QgsTextBackgroundSettings.ShapeSVG)
1758        format.background().setSize(QSizeF(20, 20))
1759        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
1760        format.background().setSizeUnit(QgsUnitTypes.RenderMapUnits)
1761        assert self.checkRender(format, 'background_svg_fixed_mapunits', QgsTextRenderer.Background)
1762
1763    def testDrawBackgroundSvgFixedMM(self):
1764        format = QgsTextFormat()
1765        format.setFont(getTestFont('bold'))
1766        format.background().setEnabled(True)
1767        svg = os.path.join(
1768            svgSymbolsPath(), 'backgrounds', 'background_square.svg')
1769        format.background().setSvgFile(svg)
1770        format.background().setType(QgsTextBackgroundSettings.ShapeSVG)
1771        format.background().setSize(QSizeF(30, 30))
1772        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
1773        format.background().setSizeUnit(QgsUnitTypes.RenderMillimeters)
1774        assert self.checkRender(format, 'background_svg_fixed_mm', QgsTextRenderer.Background)
1775
1776    def testDrawBackgroundRotationSynced(self):
1777        format = QgsTextFormat()
1778        format.setFont(getTestFont('bold'))
1779        format.background().setEnabled(True)
1780        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1781        format.background().setSize(QSizeF(30, 20))
1782        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
1783        format.background().setSizeUnit(QgsUnitTypes.RenderMillimeters)
1784        format.background().setRotation(45)  # should be ignored
1785        format.background().setRotationType(QgsTextBackgroundSettings.RotationSync)
1786        assert self.checkRender(format, 'background_rotation_sync', QgsTextRenderer.Background, angle=20)
1787
1788    def testDrawBackgroundSvgBufferPixels(self):
1789        format = QgsTextFormat()
1790        format.setFont(getTestFont('bold'))
1791        format.background().setEnabled(True)
1792        svg = os.path.join(
1793            svgSymbolsPath(), 'backgrounds', 'background_square.svg')
1794        format.background().setSvgFile(svg)
1795        format.background().setType(QgsTextBackgroundSettings.ShapeSVG)
1796        format.background().setSize(QSizeF(30, 30))
1797        format.background().setSizeType(QgsTextBackgroundSettings.SizeBuffer)
1798        format.background().setSizeUnit(QgsUnitTypes.RenderPixels)
1799        assert self.checkRender(format, 'background_svg_buffer_pixels', QgsTextRenderer.Background,
1800                                rect=QRectF(100, 100, 100, 100))
1801
1802    def testDrawBackgroundSvgBufferMapUnits(self):
1803        format = QgsTextFormat()
1804        format.setFont(getTestFont('bold'))
1805        format.background().setEnabled(True)
1806        svg = os.path.join(
1807            svgSymbolsPath(), 'backgrounds', 'background_square.svg')
1808        format.background().setSvgFile(svg)
1809        format.background().setType(QgsTextBackgroundSettings.ShapeSVG)
1810        format.background().setSize(QSizeF(4, 4))
1811        format.background().setSizeType(QgsTextBackgroundSettings.SizeBuffer)
1812        format.background().setSizeUnit(QgsUnitTypes.RenderMapUnits)
1813        assert self.checkRender(format, 'background_svg_buffer_mapunits', QgsTextRenderer.Background,
1814                                rect=QRectF(100, 100, 100, 100))
1815
1816    def testDrawBackgroundSvgBufferMM(self):
1817        format = QgsTextFormat()
1818        format.setFont(getTestFont('bold'))
1819        format.background().setEnabled(True)
1820        svg = os.path.join(
1821            svgSymbolsPath(), 'backgrounds', 'background_square.svg')
1822        format.background().setSvgFile(svg)
1823        format.background().setType(QgsTextBackgroundSettings.ShapeSVG)
1824        format.background().setSize(QSizeF(10, 10))
1825        format.background().setSizeType(QgsTextBackgroundSettings.SizeBuffer)
1826        format.background().setSizeUnit(QgsUnitTypes.RenderMillimeters)
1827        assert self.checkRender(format, 'background_svg_buffer_mm', QgsTextRenderer.Background,
1828                                rect=QRectF(100, 100, 100, 100))
1829
1830    def testDrawBackgroundMarkerFixedPixels(self):
1831        format = QgsTextFormat()
1832        format.setFont(getTestFont('bold'))
1833        format.background().setEnabled(True)
1834        format.background().setMarkerSymbol(QgsMarkerSymbol.createSimple(
1835            {'color': '#ffffff', 'size': '3', 'outline_color': 'red', 'outline_width': '3'}))
1836        format.background().setType(QgsTextBackgroundSettings.ShapeMarkerSymbol)
1837        format.background().setSize(QSizeF(60, 80))
1838        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
1839        format.background().setSizeUnit(QgsUnitTypes.RenderPixels)
1840        assert self.checkRender(format, 'background_marker_fixed_pixels', QgsTextRenderer.Background)
1841
1842    def testDrawBackgroundMarkerFixedMapUnits(self):
1843        format = QgsTextFormat()
1844        format.setFont(getTestFont('bold'))
1845        format.background().setEnabled(True)
1846        format.background().setMarkerSymbol(QgsMarkerSymbol.createSimple(
1847            {'color': '#ffffff', 'size': '3', 'outline_color': 'red', 'outline_width': '3'}))
1848        format.background().setType(QgsTextBackgroundSettings.ShapeMarkerSymbol)
1849        format.background().setSize(QSizeF(20, 20))
1850        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
1851        format.background().setSizeUnit(QgsUnitTypes.RenderMapUnits)
1852        assert self.checkRender(format, 'background_marker_fixed_mapunits', QgsTextRenderer.Background)
1853
1854    def testDrawBackgroundMarkerFixedMM(self):
1855        format = QgsTextFormat()
1856        format.setFont(getTestFont('bold'))
1857        format.background().setEnabled(True)
1858        format.background().setMarkerSymbol(QgsMarkerSymbol.createSimple(
1859            {'color': '#ffffff', 'size': '3', 'outline_color': 'red', 'outline_width': '3'}))
1860        format.background().setType(QgsTextBackgroundSettings.ShapeMarkerSymbol)
1861        format.background().setSize(QSizeF(30, 30))
1862        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
1863        format.background().setSizeUnit(QgsUnitTypes.RenderMillimeters)
1864        assert self.checkRender(format, 'background_marker_fixed_mm', QgsTextRenderer.Background)
1865
1866    def testDrawBackgroundMarkerBufferPixels(self):
1867        format = QgsTextFormat()
1868        format.setFont(getTestFont('bold'))
1869        format.background().setEnabled(True)
1870        format.background().setMarkerSymbol(QgsMarkerSymbol.createSimple(
1871            {'color': '#ffffff', 'size': '3', 'outline_color': 'red', 'outline_width': '3'}))
1872        format.background().setType(QgsTextBackgroundSettings.ShapeMarkerSymbol)
1873        format.background().setSize(QSizeF(30, 30))
1874        format.background().setSizeType(QgsTextBackgroundSettings.SizeBuffer)
1875        format.background().setSizeUnit(QgsUnitTypes.RenderPixels)
1876        assert self.checkRender(format, 'background_marker_buffer_pixels', QgsTextRenderer.Background,
1877                                rect=QRectF(100, 100, 100, 100))
1878
1879    def testDrawBackgroundMarkerBufferMapUnits(self):
1880        format = QgsTextFormat()
1881        format.setFont(getTestFont('bold'))
1882        format.background().setEnabled(True)
1883        format.background().setMarkerSymbol(QgsMarkerSymbol.createSimple(
1884            {'color': '#ffffff', 'size': '3', 'outline_color': 'red', 'outline_width': '3'}))
1885        format.background().setType(QgsTextBackgroundSettings.ShapeMarkerSymbol)
1886        format.background().setSize(QSizeF(4, 4))
1887        format.background().setSizeType(QgsTextBackgroundSettings.SizeBuffer)
1888        format.background().setSizeUnit(QgsUnitTypes.RenderMapUnits)
1889        assert self.checkRender(format, 'background_marker_buffer_mapunits', QgsTextRenderer.Background,
1890                                rect=QRectF(100, 100, 100, 100))
1891
1892    def testDrawBackgroundMarkerBufferMM(self):
1893        format = QgsTextFormat()
1894        format.setFont(getTestFont('bold'))
1895        format.background().setEnabled(True)
1896        format.background().setMarkerSymbol(QgsMarkerSymbol.createSimple(
1897            {'color': '#ffffff', 'size': '3', 'outline_color': 'red', 'outline_width': '3'}))
1898        format.background().setType(QgsTextBackgroundSettings.ShapeMarkerSymbol)
1899        format.background().setSize(QSizeF(10, 10))
1900        format.background().setSizeType(QgsTextBackgroundSettings.SizeBuffer)
1901        format.background().setSizeUnit(QgsUnitTypes.RenderMillimeters)
1902        assert self.checkRender(format, 'background_marker_buffer_mm', QgsTextRenderer.Background,
1903                                rect=QRectF(100, 100, 100, 100))
1904
1905    def testDrawBackgroundRotationFixed(self):
1906        format = QgsTextFormat()
1907        format.setFont(getTestFont('bold'))
1908        format.background().setEnabled(True)
1909        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1910        format.background().setSize(QSizeF(30, 20))
1911        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
1912        format.background().setSizeUnit(QgsUnitTypes.RenderMillimeters)
1913        format.background().setRotation(45)
1914        format.background().setRotationType(QgsTextBackgroundSettings.RotationFixed)
1915        assert self.checkRender(format, 'background_rotation_fixed', QgsTextRenderer.Background, angle=20)
1916
1917    def testDrawRotationOffset(self):
1918        format = QgsTextFormat()
1919        format.setFont(getTestFont('bold'))
1920        format.background().setEnabled(True)
1921        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1922        format.background().setSize(QSizeF(30, 20))
1923        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
1924        format.background().setSizeUnit(QgsUnitTypes.RenderMillimeters)
1925        format.background().setRotation(45)
1926        format.background().setRotationType(QgsTextBackgroundSettings.RotationOffset)
1927        assert self.checkRender(format, 'background_rotation_offset', QgsTextRenderer.Background, angle=20)
1928
1929    def testDrawBackgroundOffsetMM(self):
1930        format = QgsTextFormat()
1931        format.setFont(getTestFont('bold'))
1932        format.background().setEnabled(True)
1933        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1934        format.background().setSize(QSizeF(30, 20))
1935        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
1936        format.background().setSizeUnit(QgsUnitTypes.RenderMillimeters)
1937        format.background().setOffset(QPointF(30, 20))
1938        format.background().setOffsetUnit(QgsUnitTypes.RenderMillimeters)
1939        assert self.checkRender(format, 'background_offset_mm', QgsTextRenderer.Background)
1940
1941    def testDrawBackgroundOffsetMapUnits(self):
1942        format = QgsTextFormat()
1943        format.setFont(getTestFont('bold'))
1944        format.background().setEnabled(True)
1945        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1946        format.background().setSize(QSizeF(30, 20))
1947        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
1948        format.background().setSizeUnit(QgsUnitTypes.RenderMillimeters)
1949        format.background().setOffset(QPointF(10, 5))
1950        format.background().setOffsetUnit(QgsUnitTypes.RenderMapUnits)
1951        assert self.checkRender(format, 'background_offset_mapunits', QgsTextRenderer.Background)
1952
1953    def testDrawBackgroundRadiiMM(self):
1954        format = QgsTextFormat()
1955        format.setFont(getTestFont('bold'))
1956        format.background().setEnabled(True)
1957        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1958        format.background().setSize(QSizeF(30, 20))
1959        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
1960        format.background().setSizeUnit(QgsUnitTypes.RenderMillimeters)
1961        format.background().setRadii(QSizeF(6, 4))
1962        format.background().setRadiiUnit(QgsUnitTypes.RenderMillimeters)
1963        assert self.checkRender(format, 'background_radii_mm', QgsTextRenderer.Background)
1964
1965    def testDrawBackgroundRadiiMapUnits(self):
1966        format = QgsTextFormat()
1967        format.setFont(getTestFont('bold'))
1968        format.background().setEnabled(True)
1969        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1970        format.background().setSize(QSizeF(30, 20))
1971        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
1972        format.background().setSizeUnit(QgsUnitTypes.RenderMillimeters)
1973        format.background().setRadii(QSizeF(3, 2))
1974        format.background().setRadiiUnit(QgsUnitTypes.RenderMapUnits)
1975        assert self.checkRender(format, 'background_radii_mapunits', QgsTextRenderer.Background)
1976
1977    def testDrawBackgroundOpacity(self):
1978        format = QgsTextFormat()
1979        format.setFont(getTestFont('bold'))
1980        format.background().setEnabled(True)
1981        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1982        format.background().setSize(QSizeF(30, 20))
1983        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
1984        format.background().setOpacity(0.6)
1985        assert self.checkRender(format, 'background_opacity', QgsTextRenderer.Background)
1986
1987    def testDrawBackgroundFillColor(self):
1988        format = QgsTextFormat()
1989        format.setFont(getTestFont('bold'))
1990        format.background().setEnabled(True)
1991        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
1992        format.background().setSize(QSizeF(30, 20))
1993        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
1994        format.background().setFillColor(QColor(50, 100, 50))
1995        assert self.checkRender(format, 'background_fillcolor', QgsTextRenderer.Background)
1996
1997    def testDrawBackgroundStroke(self):
1998        format = QgsTextFormat()
1999        format.setFont(getTestFont('bold'))
2000        format.background().setEnabled(True)
2001        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
2002        format.background().setSize(QSizeF(30, 20))
2003        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
2004        format.background().setStrokeColor(QColor(50, 100, 50))
2005        format.background().setStrokeWidth(3)
2006        format.background().setStrokeWidthUnit(QgsUnitTypes.RenderMillimeters)
2007        assert self.checkRender(format, 'background_outline', QgsTextRenderer.Background)
2008
2009    def testDrawBackgroundEffect(self):
2010        format = QgsTextFormat()
2011        format.setFont(getTestFont('bold'))
2012        format.setSize(60)
2013        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2014        format.background().setEnabled(True)
2015        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
2016        format.background().setSize(QSizeF(30, 20))
2017        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
2018        format.background().setPaintEffect(QgsBlurEffect.create({'blur_level': '10', 'enabled': '1'}))
2019        assert self.checkRender(format, 'background_effect', QgsTextRenderer.Background, text=['test'])
2020
2021    def testDrawText(self):
2022        format = QgsTextFormat()
2023        format.setFont(getTestFont('bold'))
2024        format.setSize(60)
2025        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2026        assert self.checkRender(format, 'text_bold', QgsTextRenderer.Text, text=['test'])
2027
2028    def testDrawTextPoint(self):
2029        format = QgsTextFormat()
2030        format.setFont(getTestFont('bold'))
2031        format.setSize(60)
2032        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2033        assert self.checkRenderPoint(format, 'text_point_bold', QgsTextRenderer.Text, text=['test'])
2034
2035    def testDrawTextNamedStyle(self):
2036        format = QgsTextFormat()
2037        format.setFont(getTestFont('bold'))
2038        # need to call getTestFont to make sure font style is installed and ready to go
2039        temp_font = getTestFont('Bold Oblique')  # NOQA
2040        format.setFont(getTestFont())
2041        format.setNamedStyle('Bold Oblique')
2042        format.setSize(60)
2043        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2044        assert self.checkRender(format, 'text_named_style', QgsTextRenderer.Text, text=['test'])
2045
2046    def testDrawTextColor(self):
2047        format = QgsTextFormat()
2048        format.setFont(getTestFont('bold'))
2049        format.setSize(60)
2050        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2051        format.setColor(QColor(0, 255, 0))
2052        assert self.checkRender(format, 'text_color', QgsTextRenderer.Text, text=['test'])
2053
2054    def testDrawTextOpacity(self):
2055        format = QgsTextFormat()
2056        format.setFont(getTestFont('bold'))
2057        format.setSize(60)
2058        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2059        format.setOpacity(0.7)
2060        assert self.checkRender(format, 'text_opacity', QgsTextRenderer.Text, text=['test'])
2061
2062    def testDrawTextBlendMode(self):
2063        format = QgsTextFormat()
2064        format.setFont(getTestFont('bold'))
2065        format.setSize(60)
2066        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2067        format.setColor(QColor(100, 100, 100))
2068        format.setBlendMode(QPainter.CompositionMode_Difference)
2069        assert self.checkRender(format, 'text_blend_mode', QgsTextRenderer.Text, text=['test'])
2070
2071    def testDrawTextAngle(self):
2072        format = QgsTextFormat()
2073        format.setFont(getTestFont('bold'))
2074        format.setSize(60)
2075        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2076        assert self.checkRender(format, 'text_angled', QgsTextRenderer.Text, angle=90 / 180 * 3.141, text=['test'])
2077
2078    def testDrawTextMapUnits(self):
2079        format = QgsTextFormat()
2080        format.setFont(getTestFont('bold'))
2081        format.setSize(5)
2082        format.setSizeUnit(QgsUnitTypes.RenderMapUnits)
2083        assert self.checkRender(format, 'text_mapunits', QgsTextRenderer.Text, text=['test'])
2084
2085    def testDrawTextPixels(self):
2086        format = QgsTextFormat()
2087        format.setFont(getTestFont('bold'))
2088        format.setSize(50)
2089        format.setSizeUnit(QgsUnitTypes.RenderPixels)
2090        assert self.checkRender(format, 'text_pixels', QgsTextRenderer.Text, text=['test'])
2091
2092    def testDrawMultiLineText(self):
2093        format = QgsTextFormat()
2094        format.setFont(getTestFont('bold'))
2095        format.setSize(30)
2096        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2097        assert self.checkRender(format, 'text_multiline', QgsTextRenderer.Text, text=['test', 'multi', 'line'])
2098
2099    def testDrawMultiLineTextPoint(self):
2100        format = QgsTextFormat()
2101        format.setFont(getTestFont('bold'))
2102        format.setSize(30)
2103        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2104        assert self.checkRenderPoint(format, 'text_point_multiline', QgsTextRenderer.Text,
2105                                     text=['test', 'multi', 'line'])
2106
2107    def testDrawLineHeightText(self):
2108        format = QgsTextFormat()
2109        format.setFont(getTestFont('bold'))
2110        format.setSize(30)
2111        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2112        format.setLineHeight(1.5)
2113        assert self.checkRender(format, 'text_line_height', QgsTextRenderer.Text, text=['test', 'multi', 'line'])
2114
2115    def testDrawBufferSizeMM(self):
2116        format = QgsTextFormat()
2117        format.setFont(getTestFont('bold'))
2118        format.setSize(60)
2119        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2120        format.buffer().setEnabled(True)
2121        format.buffer().setSize(2)
2122        format.buffer().setSizeUnit(QgsUnitTypes.RenderMillimeters)
2123        assert self.checkRender(format, 'text_buffer_mm', QgsTextRenderer.Buffer, text=['test'])
2124
2125    def testDrawBufferDisabled(self):
2126        format = QgsTextFormat()
2127        format.setFont(getTestFont('bold'))
2128        format.setSize(60)
2129        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2130        format.buffer().setEnabled(False)
2131        assert self.checkRender(format, 'text_disabled_buffer', QgsTextRenderer.Buffer, text=['test'])
2132
2133    def testDrawBufferSizeMapUnits(self):
2134        format = QgsTextFormat()
2135        format.setFont(getTestFont('bold'))
2136        format.setSize(60)
2137        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2138        format.buffer().setEnabled(True)
2139        format.buffer().setSize(2)
2140        format.buffer().setSizeUnit(QgsUnitTypes.RenderMapUnits)
2141        assert self.checkRender(format, 'text_buffer_mapunits', QgsTextRenderer.Buffer, text=['test'])
2142
2143    def testDrawBufferSizePixels(self):
2144        format = QgsTextFormat()
2145        format.setFont(getTestFont('bold'))
2146        format.setSize(60)
2147        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2148        format.buffer().setEnabled(True)
2149        format.buffer().setSize(10)
2150        format.buffer().setSizeUnit(QgsUnitTypes.RenderPixels)
2151        assert self.checkRender(format, 'text_buffer_pixels', QgsTextRenderer.Buffer, text=['test'])
2152
2153    def testDrawBufferColor(self):
2154        format = QgsTextFormat()
2155        format.setFont(getTestFont('bold'))
2156        format.setSize(60)
2157        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2158        format.buffer().setEnabled(True)
2159        format.buffer().setSize(2)
2160        format.buffer().setSizeUnit(QgsUnitTypes.RenderMillimeters)
2161        format.buffer().setColor(QColor(0, 255, 0))
2162        assert self.checkRender(format, 'text_buffer_color', QgsTextRenderer.Buffer, text=['test'])
2163
2164    def testDrawBufferOpacity(self):
2165        format = QgsTextFormat()
2166        format.setFont(getTestFont('bold'))
2167        format.setSize(60)
2168        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2169        format.buffer().setEnabled(True)
2170        format.buffer().setSize(2)
2171        format.buffer().setSizeUnit(QgsUnitTypes.RenderMillimeters)
2172        format.buffer().setOpacity(0.5)
2173        assert self.checkRender(format, 'text_buffer_opacity', QgsTextRenderer.Buffer, text=['test'])
2174
2175    def testDrawBufferFillInterior(self):
2176        format = QgsTextFormat()
2177        format.setFont(getTestFont('bold'))
2178        format.setSize(60)
2179        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2180        format.buffer().setEnabled(True)
2181        format.buffer().setSize(2)
2182        format.buffer().setSizeUnit(QgsUnitTypes.RenderMillimeters)
2183        format.buffer().setFillBufferInterior(True)
2184        assert self.checkRender(format, 'text_buffer_interior', QgsTextRenderer.Buffer, text=['test'])
2185
2186    def testDrawBufferEffect(self):
2187        format = QgsTextFormat()
2188        format.setFont(getTestFont('bold'))
2189        format.setSize(60)
2190        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2191        format.buffer().setEnabled(True)
2192        format.buffer().setSize(2)
2193        format.buffer().setSizeUnit(QgsUnitTypes.RenderMillimeters)
2194        format.buffer().setPaintEffect(QgsBlurEffect.create({'blur_level': '10', 'enabled': '1'}))
2195        assert self.checkRender(format, 'text_buffer_effect', QgsTextRenderer.Buffer, text=['test'])
2196
2197    def testDrawShadow(self):
2198        format = QgsTextFormat()
2199        format.setFont(getTestFont('bold'))
2200        format.setSize(60)
2201        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2202        format.setColor(QColor(255, 255, 255))
2203        format.shadow().setEnabled(True)
2204        format.shadow().setShadowPlacement(QgsTextShadowSettings.ShadowText)
2205        format.shadow().setOpacity(1.0)
2206        format.shadow().setBlurRadius(0)
2207        format.shadow().setOffsetDistance(5)
2208        format.shadow().setOffsetUnit(QgsUnitTypes.RenderMillimeters)
2209        assert self.checkRender(format, 'shadow_enabled', QgsTextRenderer.Text, text=['test'])
2210
2211    def testDrawShadowOffsetAngle(self):
2212        format = QgsTextFormat()
2213        format.setFont(getTestFont('bold'))
2214        format.setSize(60)
2215        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2216        format.setColor(QColor(255, 255, 255))
2217        format.shadow().setEnabled(True)
2218        format.shadow().setShadowPlacement(QgsTextShadowSettings.ShadowText)
2219        format.shadow().setOpacity(1.0)
2220        format.shadow().setBlurRadius(0)
2221        format.shadow().setOffsetDistance(5)
2222        format.shadow().setOffsetAngle(0)
2223        format.shadow().setOffsetUnit(QgsUnitTypes.RenderMillimeters)
2224        assert self.checkRender(format, 'shadow_offset_angle', QgsTextRenderer.Text, text=['test'])
2225
2226    def testDrawShadowOffsetMapUnits(self):
2227        format = QgsTextFormat()
2228        format.setFont(getTestFont('bold'))
2229        format.setSize(60)
2230        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2231        format.setColor(QColor(255, 255, 255))
2232        format.shadow().setEnabled(True)
2233        format.shadow().setShadowPlacement(QgsTextShadowSettings.ShadowText)
2234        format.shadow().setOpacity(1.0)
2235        format.shadow().setBlurRadius(0)
2236        format.shadow().setOffsetDistance(10)
2237        format.shadow().setOffsetUnit(QgsUnitTypes.RenderMapUnits)
2238        assert self.checkRender(format, 'shadow_offset_mapunits', QgsTextRenderer.Text, text=['test'])
2239
2240    def testDrawShadowOffsetPixels(self):
2241        format = QgsTextFormat()
2242        format.setFont(getTestFont('bold'))
2243        format.setSize(60)
2244        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2245        format.setColor(QColor(255, 255, 255))
2246        format.shadow().setEnabled(True)
2247        format.shadow().setShadowPlacement(QgsTextShadowSettings.ShadowText)
2248        format.shadow().setOpacity(1.0)
2249        format.shadow().setBlurRadius(0)
2250        format.shadow().setOffsetDistance(10)
2251        format.shadow().setOffsetUnit(QgsUnitTypes.RenderPixels)
2252        assert self.checkRender(format, 'shadow_offset_pixels', QgsTextRenderer.Text, text=['test'])
2253
2254    def testDrawShadowBlurRadiusMM(self):
2255        format = QgsTextFormat()
2256        format.setFont(getTestFont('bold'))
2257        format.setSize(60)
2258        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2259        format.setColor(QColor(255, 255, 255))
2260        format.shadow().setEnabled(True)
2261        format.shadow().setShadowPlacement(QgsTextShadowSettings.ShadowText)
2262        format.shadow().setOpacity(1.0)
2263        format.shadow().setOffsetDistance(5)
2264        format.shadow().setOffsetUnit(QgsUnitTypes.RenderMillimeters)
2265        format.shadow().setBlurRadius(1)
2266        format.shadow().setBlurRadiusUnit(QgsUnitTypes.RenderMillimeters)
2267        assert self.checkRender(format, 'shadow_radius_mm', QgsTextRenderer.Text, text=['test'])
2268
2269    def testDrawShadowBlurRadiusMapUnits(self):
2270        format = QgsTextFormat()
2271        format.setFont(getTestFont('bold'))
2272        format.setSize(60)
2273        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2274        format.setColor(QColor(255, 255, 255))
2275        format.shadow().setEnabled(True)
2276        format.shadow().setShadowPlacement(QgsTextShadowSettings.ShadowText)
2277        format.shadow().setOpacity(1.0)
2278        format.shadow().setOffsetDistance(5)
2279        format.shadow().setOffsetUnit(QgsUnitTypes.RenderMillimeters)
2280        format.shadow().setBlurRadius(3)
2281        format.shadow().setBlurRadiusUnit(QgsUnitTypes.RenderMapUnits)
2282        assert self.checkRender(format, 'shadow_radius_mapunits', QgsTextRenderer.Text, text=['test'])
2283
2284    def testDrawShadowBlurRadiusPixels(self):
2285        format = QgsTextFormat()
2286        format.setFont(getTestFont('bold'))
2287        format.setSize(60)
2288        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2289        format.setColor(QColor(255, 255, 255))
2290        format.shadow().setEnabled(True)
2291        format.shadow().setShadowPlacement(QgsTextShadowSettings.ShadowText)
2292        format.shadow().setOpacity(1.0)
2293        format.shadow().setOffsetDistance(5)
2294        format.shadow().setOffsetUnit(QgsUnitTypes.RenderMillimeters)
2295        format.shadow().setBlurRadius(3)
2296        format.shadow().setBlurRadiusUnit(QgsUnitTypes.RenderPixels)
2297        assert self.checkRender(format, 'shadow_radius_pixels', QgsTextRenderer.Text, text=['test'])
2298
2299    def testDrawShadowOpacity(self):
2300        format = QgsTextFormat()
2301        format.setFont(getTestFont('bold'))
2302        format.setSize(60)
2303        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2304        format.setColor(QColor(255, 255, 255))
2305        format.shadow().setEnabled(True)
2306        format.shadow().setShadowPlacement(QgsTextShadowSettings.ShadowText)
2307        format.shadow().setOpacity(0.5)
2308        format.shadow().setBlurRadius(0)
2309        format.shadow().setOffsetDistance(5)
2310        format.shadow().setOffsetUnit(QgsUnitTypes.RenderMillimeters)
2311        assert self.checkRender(format, 'shadow_opacity', QgsTextRenderer.Text, text=['test'])
2312
2313    def testDrawShadowColor(self):
2314        format = QgsTextFormat()
2315        format.setFont(getTestFont('bold'))
2316        format.setSize(60)
2317        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2318        format.setColor(QColor(255, 255, 255))
2319        format.shadow().setEnabled(True)
2320        format.shadow().setShadowPlacement(QgsTextShadowSettings.ShadowText)
2321        format.shadow().setColor(QColor(255, 255, 0))
2322        format.shadow().setBlurRadius(0)
2323        format.shadow().setOffsetDistance(5)
2324        format.shadow().setOffsetUnit(QgsUnitTypes.RenderMillimeters)
2325        assert self.checkRender(format, 'shadow_color', QgsTextRenderer.Text, text=['test'])
2326
2327    def testDrawShadowScale(self):
2328        format = QgsTextFormat()
2329        format.setFont(getTestFont('bold'))
2330        format.setSize(60)
2331        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2332        format.setColor(QColor(255, 255, 255))
2333        format.shadow().setEnabled(True)
2334        format.shadow().setShadowPlacement(QgsTextShadowSettings.ShadowText)
2335        format.shadow().setScale(50)
2336        format.shadow().setBlurRadius(0)
2337        format.shadow().setOffsetDistance(5)
2338        format.shadow().setOffsetUnit(QgsUnitTypes.RenderMillimeters)
2339        assert self.checkRender(format, 'shadow_scale_50', QgsTextRenderer.Text, text=['test'])
2340
2341    def testDrawShadowScaleUp(self):
2342        format = QgsTextFormat()
2343        format.setFont(getTestFont('bold'))
2344        format.setSize(60)
2345        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2346        format.setColor(QColor(255, 255, 255))
2347        format.shadow().setEnabled(True)
2348        format.shadow().setShadowPlacement(QgsTextShadowSettings.ShadowText)
2349        format.shadow().setScale(150)
2350        format.shadow().setBlurRadius(0)
2351        format.shadow().setOffsetDistance(5)
2352        format.shadow().setOffsetUnit(QgsUnitTypes.RenderMillimeters)
2353        assert self.checkRender(format, 'shadow_scale_150', QgsTextRenderer.Text, text=['test'])
2354
2355    def testDrawShadowBackgroundPlacement(self):
2356        format = QgsTextFormat()
2357        format.setFont(getTestFont('bold'))
2358        format.setSize(60)
2359        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2360        format.setColor(QColor(255, 255, 255))
2361        format.shadow().setEnabled(True)
2362        format.shadow().setShadowPlacement(QgsTextShadowSettings.ShadowShape)
2363        format.shadow().setBlurRadius(0)
2364        format.shadow().setOffsetDistance(5)
2365        format.shadow().setOffsetUnit(QgsUnitTypes.RenderMillimeters)
2366        format.background().setEnabled(True)
2367        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
2368        format.background().setSize(QSizeF(20, 10))
2369        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
2370        format.background().setSizeUnit(QgsUnitTypes.RenderMapUnits)
2371        assert self.checkRender(format, 'shadow_placement_background', QgsTextRenderer.Background, text=['test'])
2372
2373    def testDrawShadowBufferPlacement(self):
2374        format = QgsTextFormat()
2375        format.setFont(getTestFont('bold'))
2376        format.setSize(60)
2377        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2378        format.setColor(QColor(255, 255, 255))
2379        format.shadow().setEnabled(True)
2380        format.shadow().setShadowPlacement(QgsTextShadowSettings.ShadowBuffer)
2381        format.shadow().setBlurRadius(0)
2382        format.shadow().setOffsetDistance(5)
2383        format.shadow().setOffsetUnit(QgsUnitTypes.RenderMillimeters)
2384        format.buffer().setEnabled(True)
2385        format.buffer().setSize(4)
2386        format.buffer().setSizeUnit(QgsUnitTypes.RenderMillimeters)
2387        assert self.checkRender(format, 'shadow_placement_buffer', QgsTextRenderer.Buffer, text=['test'])
2388
2389    def testDrawTextWithBuffer(self):
2390        format = QgsTextFormat()
2391        format.setFont(getTestFont('bold'))
2392        format.setSize(60)
2393        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2394        format.buffer().setEnabled(True)
2395        format.buffer().setSize(4)
2396        format.buffer().setSizeUnit(QgsUnitTypes.RenderMillimeters)
2397        assert self.checkRender(format, 'text_with_buffer', text=['test'], rect=QRectF(100, 100, 200, 100))
2398
2399    def testDrawTextWithBackground(self):
2400        format = QgsTextFormat()
2401        format.setFont(getTestFont('bold'))
2402        format.setSize(60)
2403        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2404        format.background().setEnabled(True)
2405        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
2406        format.background().setSize(QSizeF(20, 10))
2407        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
2408        format.background().setSizeUnit(QgsUnitTypes.RenderMapUnits)
2409        assert self.checkRender(format, 'text_with_background', text=['test'], rect=QRectF(100, 100, 200, 100))
2410
2411    def testDrawTextWithBufferAndBackground(self):
2412        format = QgsTextFormat()
2413        format.setFont(getTestFont('bold'))
2414        format.setSize(60)
2415        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2416        format.background().setEnabled(True)
2417        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
2418        format.background().setSize(QSizeF(20, 10))
2419        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
2420        format.background().setSizeUnit(QgsUnitTypes.RenderMapUnits)
2421        format.buffer().setEnabled(True)
2422        format.buffer().setSize(4)
2423        format.buffer().setColor(QColor(100, 255, 100))
2424        format.buffer().setSizeUnit(QgsUnitTypes.RenderMillimeters)
2425        assert self.checkRender(format, 'text_with_buffer_and_background', text=['test'],
2426                                rect=QRectF(100, 100, 200, 100))
2427
2428    def testDrawTextWithShadowAndBuffer(self):
2429        format = QgsTextFormat()
2430        format.setFont(getTestFont('bold'))
2431        format.setSize(60)
2432        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2433        format.shadow().setEnabled(True)
2434        format.shadow().setOpacity(1.0)
2435        format.shadow().setBlurRadius(0)
2436        format.shadow().setOffsetDistance(5)
2437        format.shadow().setOffsetUnit(QgsUnitTypes.RenderMillimeters)
2438        format.shadow().setColor(QColor(255, 100, 100))
2439        format.buffer().setEnabled(True)
2440        format.buffer().setSize(4)
2441        format.buffer().setColor(QColor(100, 255, 100))
2442        format.buffer().setSizeUnit(QgsUnitTypes.RenderMillimeters)
2443        assert self.checkRender(format, 'text_with_shadow_and_buffer', text=['test'], rect=QRectF(100, 100, 200, 100))
2444
2445    def testDrawTextWithShadowBelowTextAndBuffer(self):
2446        format = QgsTextFormat()
2447        format.setFont(getTestFont('bold'))
2448        format.setSize(60)
2449        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2450        format.shadow().setEnabled(True)
2451        format.shadow().setOpacity(1.0)
2452        format.shadow().setBlurRadius(0)
2453        format.shadow().setOffsetDistance(5)
2454        format.shadow().setOffsetUnit(QgsUnitTypes.RenderMillimeters)
2455        format.shadow().setColor(QColor(255, 100, 100))
2456        format.shadow().setShadowPlacement(QgsTextShadowSettings.ShadowText)
2457        format.buffer().setEnabled(True)
2458        format.buffer().setSize(4)
2459        format.buffer().setColor(QColor(100, 255, 100))
2460        format.buffer().setSizeUnit(QgsUnitTypes.RenderMillimeters)
2461        assert self.checkRender(format, 'text_with_shadow_below_text_and_buffer', text=['test'],
2462                                rect=QRectF(100, 100, 200, 100))
2463
2464    def testDrawTextWithBackgroundAndShadow(self):
2465        format = QgsTextFormat()
2466        format.setFont(getTestFont('bold'))
2467        format.setSize(60)
2468        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2469        format.shadow().setEnabled(True)
2470        format.shadow().setOpacity(1.0)
2471        format.shadow().setBlurRadius(0)
2472        format.shadow().setOffsetDistance(5)
2473        format.shadow().setOffsetUnit(QgsUnitTypes.RenderMillimeters)
2474        format.shadow().setColor(QColor(255, 100, 100))
2475        format.background().setEnabled(True)
2476        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
2477        format.background().setSize(QSizeF(20, 10))
2478        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
2479        format.background().setSizeUnit(QgsUnitTypes.RenderMapUnits)
2480        assert self.checkRender(format, 'text_with_shadow_and_background', text=['test'],
2481                                rect=QRectF(100, 100, 200, 100))
2482
2483    def testDrawTextWithShadowBelowTextAndBackground(self):
2484        format = QgsTextFormat()
2485        format.setFont(getTestFont('bold'))
2486        format.setSize(60)
2487        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2488        format.shadow().setEnabled(True)
2489        format.shadow().setOpacity(1.0)
2490        format.shadow().setBlurRadius(0)
2491        format.shadow().setOffsetDistance(5)
2492        format.shadow().setOffsetUnit(QgsUnitTypes.RenderMillimeters)
2493        format.shadow().setColor(QColor(255, 100, 100))
2494        format.shadow().setShadowPlacement(QgsTextShadowSettings.ShadowText)
2495        format.background().setEnabled(True)
2496        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
2497        format.background().setSize(QSizeF(20, 10))
2498        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
2499        format.background().setSizeUnit(QgsUnitTypes.RenderMapUnits)
2500        assert self.checkRender(format, 'text_with_shadow_below_text_and_background', text=['test'],
2501                                rect=QRectF(100, 100, 200, 100))
2502
2503    def testDrawTextWithBackgroundBufferAndShadow(self):
2504        format = QgsTextFormat()
2505        format.setFont(getTestFont('bold'))
2506        format.setSize(60)
2507        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2508        format.shadow().setEnabled(True)
2509        format.shadow().setOpacity(1.0)
2510        format.shadow().setBlurRadius(0)
2511        format.shadow().setOffsetDistance(5)
2512        format.shadow().setOffsetUnit(QgsUnitTypes.RenderMillimeters)
2513        format.shadow().setColor(QColor(255, 100, 100))
2514        format.background().setEnabled(True)
2515        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
2516        format.background().setSize(QSizeF(20, 10))
2517        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
2518        format.background().setSizeUnit(QgsUnitTypes.RenderMapUnits)
2519        format.buffer().setEnabled(True)
2520        format.buffer().setSize(4)
2521        format.buffer().setColor(QColor(100, 255, 100))
2522        format.buffer().setSizeUnit(QgsUnitTypes.RenderMillimeters)
2523        assert self.checkRender(format, 'text_with_shadow_buffer_and_background', text=['test'],
2524                                rect=QRectF(100, 100, 200, 100))
2525
2526    def testDrawTextWithBackgroundBufferAndShadowBelowText(self):
2527        format = QgsTextFormat()
2528        format.setFont(getTestFont('bold'))
2529        format.setSize(60)
2530        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2531        format.shadow().setEnabled(True)
2532        format.shadow().setOpacity(1.0)
2533        format.shadow().setBlurRadius(0)
2534        format.shadow().setOffsetDistance(5)
2535        format.shadow().setOffsetUnit(QgsUnitTypes.RenderMillimeters)
2536        format.shadow().setColor(QColor(255, 100, 100))
2537        format.shadow().setShadowPlacement(QgsTextShadowSettings.ShadowText)
2538        format.background().setEnabled(True)
2539        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
2540        format.background().setSize(QSizeF(20, 10))
2541        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
2542        format.background().setSizeUnit(QgsUnitTypes.RenderMapUnits)
2543        format.buffer().setEnabled(True)
2544        format.buffer().setSize(4)
2545        format.buffer().setColor(QColor(100, 255, 100))
2546        format.buffer().setSizeUnit(QgsUnitTypes.RenderMillimeters)
2547        assert self.checkRender(format, 'text_with_shadow_below_text_buffer_and_background', text=['test'],
2548                                rect=QRectF(100, 100, 200, 100))
2549
2550    def testDrawTextWithBackgroundBufferAndShadowBelowBuffer(self):
2551        format = QgsTextFormat()
2552        format.setFont(getTestFont('bold'))
2553        format.setSize(60)
2554        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2555        format.shadow().setEnabled(True)
2556        format.shadow().setOpacity(1.0)
2557        format.shadow().setBlurRadius(0)
2558        format.shadow().setOffsetDistance(5)
2559        format.shadow().setOffsetUnit(QgsUnitTypes.RenderMillimeters)
2560        format.shadow().setColor(QColor(255, 100, 100))
2561        format.shadow().setShadowPlacement(QgsTextShadowSettings.ShadowBuffer)
2562        format.background().setEnabled(True)
2563        format.background().setType(QgsTextBackgroundSettings.ShapeRectangle)
2564        format.background().setSize(QSizeF(20, 10))
2565        format.background().setSizeType(QgsTextBackgroundSettings.SizeFixed)
2566        format.background().setSizeUnit(QgsUnitTypes.RenderMapUnits)
2567        format.buffer().setEnabled(True)
2568        format.buffer().setSize(4)
2569        format.buffer().setColor(QColor(100, 255, 100))
2570        format.buffer().setSizeUnit(QgsUnitTypes.RenderMillimeters)
2571        assert self.checkRender(format, 'text_with_shadow_below_buffer_and_background', text=['test'],
2572                                rect=QRectF(100, 100, 200, 100))
2573
2574    def testDrawTextRectMultilineRightAlign(self):
2575        format = QgsTextFormat()
2576        format.setFont(getTestFont('bold'))
2577        format.setSize(30)
2578        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2579        assert self.checkRender(format, 'text_rect_multiline_right_aligned', text=['test', 'right', 'aligned'],
2580                                alignment=QgsTextRenderer.AlignRight, rect=QRectF(100, 100, 200, 100))
2581
2582    def testDrawTextRectRightAlign(self):
2583        format = QgsTextFormat()
2584        format.setFont(getTestFont('bold'))
2585        format.setSize(30)
2586        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2587        assert self.checkRender(format, 'text_rect_right_aligned', text=['test'],
2588                                alignment=QgsTextRenderer.AlignRight, rect=QRectF(100, 100, 200, 100))
2589
2590    def testDrawTextRectMultilineJustifyAlign(self):
2591        format = QgsTextFormat()
2592        format.setFont(getTestFont('bold'))
2593        format.setSize(30)
2594        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2595        format.buffer().setEnabled(True)
2596        format.buffer().setSize(4)
2597        format.buffer().setSizeUnit(QgsUnitTypes.RenderMillimeters)
2598        assert self.checkRender(format, 'text_rect_multiline_justify_aligned', text=['a t est', 'off', 'justification', 'align'],
2599                                alignment=QgsTextRenderer.AlignJustify, rect=QRectF(100, 100, 200, 100))
2600
2601    def testDrawTextRectJustifyAlign(self):
2602        format = QgsTextFormat()
2603        format.setFont(getTestFont('bold'))
2604        format.setSize(30)
2605        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2606        assert self.checkRender(format, 'text_rect_justify_aligned', text=['test'],
2607                                alignment=QgsTextRenderer.AlignJustify, rect=QRectF(100, 100, 200, 100))
2608
2609    def testDrawTextRectMultilineBottomAlign(self):
2610        format = QgsTextFormat()
2611        format.setFont(getTestFont('bold'))
2612        format.setSize(30)
2613        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2614
2615        assert self.checkRender(format, 'text_rect_multiline_bottom_aligned', text=['test', 'bottom', 'aligned'],
2616                                alignment=QgsTextRenderer.AlignLeft, rect=QRectF(100, 100, 200, 100), vAlignment=QgsTextRenderer.AlignBottom)
2617
2618    def testDrawTextRectBottomAlign(self):
2619        format = QgsTextFormat()
2620        format.setFont(getTestFont('bold'))
2621        format.setSize(30)
2622        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2623
2624        assert self.checkRender(format, 'text_rect_bottom_aligned', text=['bottom aligned'],
2625                                alignment=QgsTextRenderer.AlignLeft, rect=QRectF(100, 100, 200, 100), vAlignment=QgsTextRenderer.AlignBottom)
2626
2627    def testDrawTextRectMultilineVCenterAlign(self):
2628        format = QgsTextFormat()
2629        format.setFont(getTestFont('bold'))
2630        format.setSize(30)
2631        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2632
2633        assert self.checkRender(format, 'text_rect_multiline_vcenter_aligned', text=['test', 'center', 'aligned'],
2634                                alignment=QgsTextRenderer.AlignLeft, rect=QRectF(100, 100, 200, 100), vAlignment=QgsTextRenderer.AlignVCenter)
2635
2636    def testDrawTextRectVCenterAlign(self):
2637        format = QgsTextFormat()
2638        format.setFont(getTestFont('bold'))
2639        format.setSize(30)
2640        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2641
2642        assert self.checkRender(format, 'text_rect_vcenter_aligned', text=['center aligned'],
2643                                alignment=QgsTextRenderer.AlignLeft, rect=QRectF(100, 100, 200, 100), vAlignment=QgsTextRenderer.AlignVCenter)
2644
2645    def testDrawTextRectMultilineCenterAlign(self):
2646        format = QgsTextFormat()
2647        format.setFont(getTestFont('bold'))
2648        format.setSize(30)
2649        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2650        assert self.checkRender(format, 'text_rect_multiline_center_aligned', text=['test', 'c', 'aligned'],
2651                                alignment=QgsTextRenderer.AlignCenter, rect=QRectF(100, 100, 200, 100))
2652
2653    def testDrawTextRectCenterAlign(self):
2654        format = QgsTextFormat()
2655        format.setFont(getTestFont('bold'))
2656        format.setFont(getTestFont('bold'))
2657        format.setSize(30)
2658        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2659        assert self.checkRender(format, 'text_rect_center_aligned', text=['test'],
2660                                alignment=QgsTextRenderer.AlignCenter, rect=QRectF(100, 100, 200, 100))
2661
2662    def testDrawTextPointMultilineRightAlign(self):
2663        format = QgsTextFormat()
2664        format.setFont(getTestFont('bold'))
2665        format.setSize(30)
2666        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2667        assert self.checkRenderPoint(format, 'text_point_right_multiline_aligned', text=['test', 'right', 'aligned'],
2668                                     alignment=QgsTextRenderer.AlignRight, point=QPointF(300, 200))
2669
2670    def testDrawTextPointMultilineCenterAlign(self):
2671        format = QgsTextFormat()
2672        format.setFont(getTestFont('bold'))
2673        format.setSize(30)
2674        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2675        assert self.checkRenderPoint(format, 'text_point_center_multiline_aligned', text=['test', 'center', 'aligned'],
2676                                     alignment=QgsTextRenderer.AlignCenter, point=QPointF(200, 200))
2677
2678    def testDrawTextPointRightAlign(self):
2679        format = QgsTextFormat()
2680        format.setFont(getTestFont('bold'))
2681        format.setSize(30)
2682        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2683        assert self.checkRenderPoint(format, 'text_point_right_aligned', text=['test'],
2684                                     alignment=QgsTextRenderer.AlignRight, point=QPointF(300, 200))
2685
2686    def testDrawTextPointJustifyAlign(self):
2687        format = QgsTextFormat()
2688        format.setFont(getTestFont('bold'))
2689        format.setSize(30)
2690        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2691        assert self.checkRenderPoint(format, 'text_point_justify_aligned', text=['test'],
2692                                     alignment=QgsTextRenderer.AlignJustify, point=QPointF(100, 200))
2693
2694    def testDrawTextPointMultilineJustifyAlign(self):
2695        format = QgsTextFormat()
2696        format.setFont(getTestFont('bold'))
2697        format.setSize(30)
2698        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2699        assert self.checkRenderPoint(format, 'text_point_justify_multiline_aligned', text=['a t est', 'off', 'justification', 'align'],
2700                                     alignment=QgsTextRenderer.AlignJustify, point=QPointF(100, 200))
2701
2702    def testDrawTextPointCenterAlign(self):
2703        format = QgsTextFormat()
2704        format.setFont(getTestFont('bold'))
2705        format.setSize(30)
2706        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2707        assert self.checkRenderPoint(format, 'text_point_center_aligned', text=['test'],
2708                                     alignment=QgsTextRenderer.AlignCenter, point=QPointF(200, 200))
2709
2710    def testDrawTextDataDefinedColorPoint(self):
2711        format = QgsTextFormat()
2712        format.setFont(getTestFont('bold'))
2713        format.setSize(60)
2714        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2715        format.setColor(QColor(0, 255, 0))
2716        format.dataDefinedProperties().setProperty(QgsPalLayerSettings.Color, QgsProperty.fromExpression("'#bb00cc'"))
2717        assert self.checkRenderPoint(format, 'text_dd_color_point', None, text=['test'], point=QPointF(50, 200))
2718
2719    def testDrawTextDataDefinedColorRect(self):
2720        format = QgsTextFormat()
2721        format.setFont(getTestFont('bold'))
2722        format.setSize(60)
2723        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2724        format.setColor(QColor(0, 255, 0))
2725        format.dataDefinedProperties().setProperty(QgsPalLayerSettings.Color, QgsProperty.fromExpression("'#bb00cc'"))
2726        assert self.checkRender(format, 'text_dd_color_rect', None, text=['test'],
2727                                alignment=QgsTextRenderer.AlignCenter, rect=QRectF(100, 100, 100, 100))
2728
2729    def testDrawTextDataDefinedBufferColorPoint(self):
2730        format = QgsTextFormat()
2731        format.setFont(getTestFont('bold'))
2732        format.setSize(60)
2733        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2734        format.setColor(QColor(0, 255, 0))
2735        format.dataDefinedProperties().setProperty(QgsPalLayerSettings.BufferColor,
2736                                                   QgsProperty.fromExpression("'#bb00cc'"))
2737        format.buffer().setEnabled(True)
2738        format.buffer().setSize(5)
2739        assert self.checkRenderPoint(format, 'text_dd_buffer_color', None, text=['test'], point=QPointF(50, 200))
2740
2741    def testHtmlFormatting(self):
2742        format = QgsTextFormat()
2743        format.setFont(getTestFont('bold'))
2744        format.setSize(60)
2745        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2746        format.setColor(QColor(0, 255, 0))
2747        format.setAllowHtmlFormatting(True)
2748        assert self.checkRenderPoint(format, 'text_html_formatting', None, text=['<s>t</s><span style="text-decoration: overline">e</span><span style="color: red">s<span style="text-decoration: underline">t</span></span>'], point=QPointF(50, 200))
2749
2750    def testHtmlFormattingBuffer(self):
2751        format = QgsTextFormat()
2752        format.setFont(getTestFont('bold'))
2753        format.setSize(60)
2754        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2755        format.setColor(QColor(0, 255, 0))
2756        format.setAllowHtmlFormatting(True)
2757        format.buffer().setEnabled(True)
2758        format.buffer().setSize(5)
2759        format.buffer().setColor(QColor(50, 150, 200))
2760        assert self.checkRenderPoint(format, 'text_html_formatting_buffer', None, text=['<s>t</s><span style="text-decoration: overline">e</span><span style="color: red">s<span style="text-decoration: underline">t</span></span>'], point=QPointF(50, 200))
2761
2762    def testHtmlFormattingShadow(self):
2763        format = QgsTextFormat()
2764        format.setFont(getTestFont('bold'))
2765        format.setSize(60)
2766        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2767        format.setColor(QColor(0, 255, 0))
2768        format.setAllowHtmlFormatting(True)
2769        format.shadow().setEnabled(True)
2770        format.shadow().setOffsetDistance(5)
2771        format.shadow().setBlurRadius(0)
2772        format.shadow().setColor(QColor(50, 150, 200))
2773        assert self.checkRenderPoint(format, 'text_html_formatting_shadow', None, text=['<s>t</s><span style="text-decoration: overline">e</span><span style="color: red">s<span style="text-decoration: underline">t</span></span>'], point=QPointF(50, 200))
2774
2775    def testHtmlFormattingBufferShadow(self):
2776        format = QgsTextFormat()
2777        format.setFont(getTestFont('bold'))
2778        format.setSize(60)
2779        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2780        format.setColor(QColor(0, 255, 0))
2781        format.setAllowHtmlFormatting(True)
2782        format.buffer().setEnabled(True)
2783        format.buffer().setSize(5)
2784        format.buffer().setColor(QColor(200, 50, 150))
2785        format.shadow().setEnabled(True)
2786        format.shadow().setOffsetDistance(5)
2787        format.shadow().setBlurRadius(0)
2788        format.shadow().setColor(QColor(50, 150, 200))
2789        assert self.checkRenderPoint(format, 'text_html_formatting_buffer_shadow', None, text=['<s>t</s><span style="text-decoration: overline">e</span><span style="color: red">s<span style="text-decoration: underline">t</span></span>'], point=QPointF(50, 200))
2790
2791    def testHtmlFormattingVertical(self):
2792        format = QgsTextFormat()
2793        format.setFont(getTestFont('bold'))
2794        format.setSize(30)
2795        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2796        format.setColor(QColor(0, 255, 0))
2797        format.setAllowHtmlFormatting(True)
2798        format.setOrientation(QgsTextFormat.VerticalOrientation)
2799        assert self.checkRenderPoint(format, 'text_html_formatting_vertical', None, text=['<s>t</s><span style="text-decoration: overline">e</span><span style="color: red">s<span style="text-decoration: underline">t</span></span>'], point=QPointF(50, 200))
2800
2801    def testHtmlFormattingBufferVertical(self):
2802        format = QgsTextFormat()
2803        format.setFont(getTestFont('bold'))
2804        format.setSize(30)
2805        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2806        format.setColor(QColor(0, 255, 0))
2807        format.setAllowHtmlFormatting(True)
2808        format.buffer().setEnabled(True)
2809        format.buffer().setSize(5)
2810        format.buffer().setColor(QColor(50, 150, 200))
2811        format.setOrientation(QgsTextFormat.VerticalOrientation)
2812        assert self.checkRenderPoint(format, 'text_html_formatting_buffer_vertical', None, text=['<s>t</s><span style="text-decoration: overline">e</span><span style="color: red">s<span style="text-decoration: underline">t</span></span>'], point=QPointF(50, 200))
2813
2814    def testTextRenderFormat(self):
2815        format = QgsTextFormat()
2816        format.setFont(getTestFont('bold'))
2817        format.setSize(30)
2818        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2819
2820        filename = '{}/test_render_text.svg'.format(QDir.tempPath())
2821        svg = QSvgGenerator()
2822        svg.setFileName(filename)
2823        svg.setSize(QSize(400, 400))
2824        svg.setResolution(600)
2825
2826        ms = QgsMapSettings()
2827        ms.setExtent(QgsRectangle(0, 0, 50, 50))
2828        ms.setOutputSize(QSize(400, 400))
2829        context = QgsRenderContext.fromMapSettings(ms)
2830
2831        # test with ALWAYS TEXT mode
2832        context.setTextRenderFormat(QgsRenderContext.TextFormatAlwaysText)
2833        painter = QPainter()
2834        context.setPainter(painter)
2835
2836        context.setScaleFactor(96 / 25.4)  # 96 DPI
2837
2838        painter.begin(svg)
2839
2840        painter.setBrush(QBrush(QColor(182, 239, 255)))
2841        painter.setPen(Qt.NoPen)
2842
2843        QgsTextRenderer.drawText(QPointF(0, 30),
2844                                 0,
2845                                 QgsTextRenderer.AlignLeft,
2846                                 ['my test text'],
2847                                 context,
2848                                 format)
2849
2850        painter.end()
2851
2852        # expect svg to contain a text object with the label
2853        with open(filename, 'r') as f:
2854            lines = ''.join(f.readlines())
2855        self.assertIn('<text', lines)
2856        self.assertIn('>my test text<', lines)
2857
2858        os.unlink(filename)
2859
2860        # test with ALWAYS CURVES mode
2861        context = QgsRenderContext.fromMapSettings(ms)
2862        context.setTextRenderFormat(QgsRenderContext.TextFormatAlwaysOutlines)
2863        painter = QPainter()
2864        context.setPainter(painter)
2865
2866        context.setScaleFactor(96 / 25.4)  # 96 DPI
2867
2868        svg = QSvgGenerator()
2869        svg.setFileName(filename)
2870        svg.setSize(QSize(400, 400))
2871        svg.setResolution(600)
2872        painter.begin(svg)
2873
2874        painter.setBrush(QBrush(QColor(182, 239, 255)))
2875        painter.setPen(Qt.NoPen)
2876
2877        QgsTextRenderer.drawText(QPointF(0, 30),
2878                                 0,
2879                                 QgsTextRenderer.AlignLeft,
2880                                 ['my test text'],
2881                                 context,
2882                                 format)
2883
2884        painter.end()
2885
2886        # expect svg to contain a text object with the label
2887        with open(filename, 'r') as f:
2888            lines = ''.join(f.readlines())
2889        self.assertNotIn('<text', lines)
2890        self.assertNotIn('>my test text<', lines)
2891
2892    def testDrawTextVerticalRectMode(self):
2893        format = QgsTextFormat()
2894        format.setFont(getTestFont('bold'))
2895        format.setSize(60)
2896        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2897        format.setOrientation(QgsTextFormat.VerticalOrientation)
2898        assert self.checkRender(format, 'text_vertical_rect_mode', QgsTextRenderer.Text, text=['1234'],
2899                                rect=QRectF(40, 20, 350, 350))
2900
2901    def testDrawTextVerticalRectModeCenterAligned(self):
2902        format = QgsTextFormat()
2903        format.setFont(getTestFont('bold'))
2904        format.setSize(60)
2905        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2906        format.setOrientation(QgsTextFormat.VerticalOrientation)
2907        assert self.checkRender(format, 'text_vertical_rect_mode_center_aligned', QgsTextRenderer.Text,
2908                                text=['1234', '5678'], rect=QRectF(40, 20, 350, 350),
2909                                alignment=QgsTextRenderer.AlignCenter)
2910
2911    def testDrawTextVerticalRectModeRightAligned(self):
2912        format = QgsTextFormat()
2913        format.setFont(getTestFont('bold'))
2914        format.setSize(60)
2915        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2916        format.setOrientation(QgsTextFormat.VerticalOrientation)
2917        assert self.checkRender(format, 'text_vertical_rect_mode_right_aligned', QgsTextRenderer.Text,
2918                                text=['1234', '5678'], rect=QRectF(40, 20, 350, 350),
2919                                alignment=QgsTextRenderer.AlignRight)
2920
2921    def testDrawTextVerticalPointMode(self):
2922        format = QgsTextFormat()
2923        format.setFont(getTestFont('bold'))
2924        format.setSize(60)
2925        format.setSizeUnit(QgsUnitTypes.RenderPoints)
2926        format.setOrientation(QgsTextFormat.VerticalOrientation)
2927        assert self.checkRenderPoint(format, 'text_vertical_point_mode', QgsTextRenderer.Text, text=['1234', '5678'],
2928                                     point=QPointF(40, 380))
2929
2930
2931if __name__ == '__main__':
2932    unittest.main()
2933