support/regression/COVERAGE


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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180

Primary goal: good coverage of the backend code generators.  The
following list was derived from the token list in SDCC.lex

Follows is a list of tokens and the test case that covers them.  If no
case is listed then the token is not yet covered.  Special cases are
listed under the token.  If the token is listed as covered then the
special cases are also covered.

The cases generally assume that on stack local variables and
parameters are accessed using the same methods and hence doesn't test
stack based parameters.

Todo
Operations:
        Shifts:
                Common cases:
                        For byte multiples (8, 16...)
                        For more than the word size
                        For negative shifts
                        For shift of 1
                >>=
                <<=
                >>
                <<

        Comparison:
                Common cases:
                        Around zero
                        Constants on either side (reversal)
                <=
                >=
                ==
                !=
                <
                >

        Basic arithmetic:
                Common cases:
                        For small constants (<3)
                ++
                --
                +=
                -=
                -
                +

        Mul/Div/Mod arithmetic:
                Common cases:
                        For powers of 2                               
                *=
                /=
                %=
                *
                /
                %

        Bitwise operations:
                &=
                ^=
                |=
                &
                ~
                ^
                |

        Logical operations:
                &&
                ||
                !

        Misc:
                ->
                        Test that members are not cached across
function calls
                =
                .
                ?
                casts
                        Test sign extension
                arrays
                        Test a[a[const]]
                pointers

        Language features (untestable):
                ;
                {
                }
                ,
                :
                (
                )
                [
                ]

Keywords:
        Specificers:
                const
                register
                signed
                static
                unsigned
                volatile

        Conditional:
                break
                case
                default
                else
                goto
                if
                switch

        Types:
                char
                double
                float
                int
                long
                short
                void

        Iterative:
                continue
                do
                for
                while

        Language features:
                enum
                extern
                sizeof
                struct
                typedef
                union

        Misc:
                return

        Unknown:
                auto
                interrupt

Optional keywords:
        banked
        bit
        flash
        code
        critical
        near
        data
        eeprom
        idata
        nonbanked
        pdata
        reentrant
        sbit
        sfr
        using
        sram
        xdata
        far
        _code
        _flash
        _eeprom
        _generic
        _idata
        _data
        _near
        _pdata
        _sram
        _xdata

Language features:
        va args (...)

Optional:
        Constants:
        	Hex, dec, oct
                Character constants	'x'
                Specials		'\n', '\0', ...