summaryrefslogtreecommitdiff
path: root/tests/glibext/strbuilder.py
blob: 72fd5c2803a8fcb1d654ec67d66f0474f91c007a (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

import gi

from chrysacase import ChrysalideTestCase
from gi.repository import GObject
from pychrysalide.glibext import StringBuilder


class TestStringBuilder(ChrysalideTestCase):
    """Test cases for pychrysalide.glibext.StringBuilder."""


    def ZZZtestStringBuilderCreation(self):
        """Create objects with StringBuilder interface."""

        with self.assertRaisesRegex(NotImplementedError, 'StringBuilder can not be constructed'):

            sb = StringBuilder()


        class NewStringBuilderImplem(gi._gi.GObject, StringBuilder):
            pass

        nsb = NewStringBuilderImplem()

        self.assertIsNotNone(nsb)


        class NewStringBuilderImplem2(GObject.Object, StringBuilder):
            pass

        nsb2 = NewStringBuilderImplem()

        self.assertIsNotNone(nsb2)


    def ZZZtestStringBuilderMethods(self):
        """Test the StringBuilder methods."""

        class BasicStringBuilderImplem(GObject.Object, StringBuilder):

            def __init__(self, desc):
                super().__init__()
                self._desc = desc

            def _to_string(self, flags=0):
                return self._desc

        desc = 'simple_desc'

        sb = BasicStringBuilderImplem(desc)

        self.assertEqual(sb.to_string(), desc)
        self.assertEqual(str(sb), desc)
        self.assertEqual(f'{sb}', desc)


    def testStringBuilderExceptions(self):
        """Raise exceptions from the StringBuilder interface as expected."""


        class BadStringBuilderImplem(GObject.Object, StringBuilder):
            pass

        obj = BadStringBuilderImplem()


        with self.assertRaisesRegex(NotImplementedError, "method implementation is missing for '_to_string'"):

            s = str(obj)


        class BadStringBuilderImplem2(GObject.Object, StringBuilder):

            def _to_string(self, flags=0):
                return 0xcafe

        obj2 = BadStringBuilderImplem2()


        with self.assertRaisesRegex(TypeError, 'object description has to get provided as an UTF-8 string value'):

            s = str(obj2)


        class BadStringBuilderImplem3a(GObject.Object, StringBuilder):

            def _to_string(self, flags=0):
                return 'desc'

        class BadStringBuilderImplem3b(BadStringBuilderImplem3a, StringBuilder):

            def _to_string(self, flags=0):
                return self.parent_to_string()

        obj3 = BadStringBuilderImplem3b()


        with self.assertRaisesRegex(RuntimeError, 'object parent is not a native type'):

            s = str(obj3)


        class BadStringBuilderImplem4(GObject.Object, StringBuilder):

            def _to_string(self, flags=0):
                raise Exception('error')

        obj4 = BadStringBuilderImplem4()


        with self.assertRaisesRegex(Exception, 'error'):

            s = str(obj4)