Debian Codegraph @

tests/test_type_kind_set.py

raw
1 # Copyright (c) Meta Platforms, Inc. and affiliates.
2 # SPDX-License-Identifier: LGPL-2.1-or-later
3
4 from drgn import TypeKind, TypeKindSet
5 from tests import TestCase
6
7
8 class TestTypeKindSet(TestCase):
9 def test_repr(self):
10 self.assertEqual(
11 repr(TypeKindSet()),
12 "TypeKindSet()",
13 )
14 self.assertEqual(
15 repr(TypeKindSet({TypeKind.STRUCT})),
16 "TypeKindSet({TypeKind.STRUCT})",
17 )
18 self.assertEqual(
19 repr(TypeKindSet({TypeKind.STRUCT, TypeKind.CLASS})),
20 "TypeKindSet({TypeKind.STRUCT, TypeKind.CLASS})",
21 )
22
23 def test_len(self):
24 self.assertEqual(len(TypeKindSet()), 0)
25 self.assertEqual(len(TypeKindSet({TypeKind.STRUCT})), 1)
26 self.assertEqual(len(TypeKindSet({TypeKind.INT, TypeKind.STRUCT})), 2)
27
28 def test_in(self):
29 self.assertNotIn(TypeKind.INT, TypeKindSet())
30 self.assertIn(TypeKind.INT, TypeKindSet({TypeKind.INT}))
31 self.assertIn(TypeKind.INT, TypeKindSet({TypeKind.INT, TypeKind.STRUCT}))
32 self.assertIn(TypeKind.STRUCT, TypeKindSet({TypeKind.INT, TypeKind.STRUCT}))
33 self.assertNotIn(TypeKind.UNION, TypeKindSet({TypeKind.INT, TypeKind.STRUCT}))
34 self.assertNotIn(0, TypeKindSet({TypeKind.INT}))
35 self.assertNotIn(TypeKind.INT.value, TypeKindSet({TypeKind.INT}))
36
37 def test_iter(self):
38 for s in (
39 set(),
40 {TypeKind.VOID},
41 {TypeKind.ARRAY, TypeKind.POINTER},
42 ):
43 self.assertEqual(set(TypeKindSet(s)), s)
44
45 def test_eq(self):
46 self.assertTrue(TypeKindSet() == TypeKindSet())
47 self.assertFalse(TypeKindSet() == TypeKindSet({TypeKind.BOOL}))
48 self.assertTrue(TypeKindSet({TypeKind.FLOAT}) == TypeKindSet({TypeKind.FLOAT}))
49 self.assertFalse(
50 TypeKindSet({TypeKind.FUNCTION}) == TypeKindSet({TypeKind.BOOL})
51 )
52 self.assertTrue(
53 TypeKindSet({TypeKind.FLOAT, TypeKind.TYPEDEF})
54 == TypeKindSet({TypeKind.FLOAT, TypeKind.TYPEDEF})
55 )
56 self.assertFalse(
57 TypeKindSet({TypeKind.BOOL, TypeKind.FUNCTION})
58 == TypeKindSet({TypeKind.BOOL, TypeKind.ARRAY}),
59 )
60 self.assertTrue(
61 TypeKindSet({TypeKind.FLOAT, TypeKind.TYPEDEF})
62 == {TypeKind.FLOAT, TypeKind.TYPEDEF}
63 )
64 self.assertFalse(TypeKindSet() == {"asdf"})
65 self.assertFalse(
66 TypeKindSet({TypeKind.FLOAT, TypeKind.TYPEDEF})
67 == {TypeKind.FLOAT, TypeKind.TYPEDEF, "foo"}
68 )
69 self.assertFalse(
70 TypeKindSet({TypeKind.FLOAT, TypeKind.TYPEDEF})
71 == [TypeKind.FLOAT, TypeKind.TYPEDEF]
72 )
73
74 def test_ne(self):
75 self.assertFalse(TypeKindSet() != TypeKindSet())
76 self.assertTrue(TypeKindSet() != TypeKindSet({TypeKind.BOOL}))
77 self.assertFalse(TypeKindSet({TypeKind.FLOAT}) != TypeKindSet({TypeKind.FLOAT}))
78 self.assertTrue(
79 TypeKindSet({TypeKind.FUNCTION}) != TypeKindSet({TypeKind.BOOL})
80 )
81 self.assertFalse(
82 TypeKindSet({TypeKind.FLOAT, TypeKind.TYPEDEF})
83 != TypeKindSet({TypeKind.FLOAT, TypeKind.TYPEDEF})
84 )
85 self.assertTrue(
86 TypeKindSet({TypeKind.BOOL, TypeKind.FUNCTION})
87 != TypeKindSet({TypeKind.BOOL, TypeKind.ARRAY}),
88 )
89 self.assertFalse(
90 TypeKindSet({TypeKind.FLOAT, TypeKind.TYPEDEF})
91 != {TypeKind.FLOAT, TypeKind.TYPEDEF}
92 )
93 self.assertTrue(TypeKindSet() != {"asdf"})
94 self.assertTrue(
95 TypeKindSet({TypeKind.FLOAT, TypeKind.TYPEDEF})
96 != {TypeKind.FLOAT, TypeKind.TYPEDEF, "foo"}
97 )
98 self.assertTrue(
99 TypeKindSet({TypeKind.FLOAT, TypeKind.TYPEDEF})
100 != [TypeKind.FLOAT, TypeKind.TYPEDEF]
101 )
102
103 def test_lt(self):
104 self.assertFalse(TypeKindSet() < TypeKindSet())
105 self.assertTrue(TypeKindSet() < TypeKindSet({TypeKind.BOOL}))
106 self.assertFalse(TypeKindSet({TypeKind.BOOL}) < TypeKindSet())
107 self.assertFalse(TypeKindSet({TypeKind.BOOL}) < TypeKindSet({TypeKind.BOOL}))
108 self.assertTrue(
109 TypeKindSet({TypeKind.BOOL}) < TypeKindSet({TypeKind.BOOL, TypeKind.FLOAT})
110 )
111 self.assertFalse(
112 TypeKindSet({TypeKind.BOOL, TypeKind.FLOAT}) < TypeKindSet({TypeKind.BOOL})
113 )
114 self.assertFalse(TypeKindSet({TypeKind.INT}) < TypeKindSet({TypeKind.BOOL}))
115 self.assertTrue(
116 TypeKindSet({TypeKind.BOOL}) < {TypeKind.BOOL, TypeKind.FLOAT, "foo"}
117 )
118 with self.assertRaises(TypeError):
119 TypeKindSet({TypeKind.BOOL}) < [TypeKind.BOOL, TypeKind.FLOAT]
120
121 def test_gt(self):
122 self.assertFalse(TypeKindSet() > TypeKindSet())
123 self.assertFalse(TypeKindSet() > TypeKindSet({TypeKind.BOOL}))
124 self.assertTrue(TypeKindSet({TypeKind.BOOL}) > TypeKindSet())
125 self.assertFalse(TypeKindSet({TypeKind.BOOL}) > TypeKindSet({TypeKind.BOOL}))
126 self.assertFalse(
127 TypeKindSet({TypeKind.BOOL}) > TypeKindSet({TypeKind.BOOL, TypeKind.FLOAT})
128 )
129 self.assertTrue(
130 TypeKindSet({TypeKind.BOOL, TypeKind.FLOAT}) > TypeKindSet({TypeKind.BOOL})
131 )
132 self.assertFalse(TypeKindSet({TypeKind.INT}) > TypeKindSet({TypeKind.BOOL}))
133 self.assertFalse(
134 TypeKindSet({TypeKind.BOOL, TypeKind.FLOAT}) > {TypeKind.BOOL, "foo"}
135 )
136 with self.assertRaises(TypeError):
137 TypeKindSet({TypeKind.BOOL}) > []
138
139 def test_le(self):
140 self.assertTrue(TypeKindSet() <= TypeKindSet())
141 self.assertTrue(TypeKindSet() <= TypeKindSet({TypeKind.BOOL}))
142 self.assertFalse(TypeKindSet({TypeKind.BOOL}) <= TypeKindSet())
143 self.assertTrue(TypeKindSet({TypeKind.BOOL}) <= TypeKindSet({TypeKind.BOOL}))
144 self.assertTrue(
145 TypeKindSet({TypeKind.BOOL}) <= TypeKindSet({TypeKind.BOOL, TypeKind.FLOAT})
146 )
147 self.assertFalse(
148 TypeKindSet({TypeKind.BOOL, TypeKind.FLOAT}) <= TypeKindSet({TypeKind.BOOL})
149 )
150 self.assertFalse(TypeKindSet({TypeKind.INT}) <= TypeKindSet({TypeKind.BOOL}))
151 self.assertTrue(TypeKindSet({TypeKind.BOOL}) <= {TypeKind.BOOL, "foo"})
152 with self.assertRaises(TypeError):
153 TypeKindSet({TypeKind.BOOL}) <= [TypeKind.BOOL, TypeKind.FLOAT]
154
155 def test_ge(self):
156 self.assertTrue(TypeKindSet() >= TypeKindSet())
157 self.assertFalse(TypeKindSet() >= TypeKindSet({TypeKind.BOOL}))
158 self.assertTrue(TypeKindSet({TypeKind.BOOL}) >= TypeKindSet())
159 self.assertTrue(TypeKindSet({TypeKind.BOOL}) >= TypeKindSet({TypeKind.BOOL}))
160 self.assertFalse(
161 TypeKindSet({TypeKind.BOOL}) >= TypeKindSet({TypeKind.BOOL, TypeKind.FLOAT})
162 )
163 self.assertTrue(
164 TypeKindSet({TypeKind.BOOL, TypeKind.FLOAT}) >= TypeKindSet({TypeKind.BOOL})
165 )
166 self.assertFalse(TypeKindSet({TypeKind.INT}) >= TypeKindSet({TypeKind.BOOL}))
167 self.assertFalse(TypeKindSet({TypeKind.BOOL}) >= {TypeKind.BOOL, "foo"})
168 with self.assertRaises(TypeError):
169 TypeKindSet({TypeKind.BOOL}) >= [TypeKind.BOOL]
170
171 def test_isdisjoint(self):
172 self.assertTrue(TypeKindSet().isdisjoint(TypeKindSet()))
173 self.assertTrue(
174 TypeKindSet({TypeKind.POINTER}).isdisjoint(TypeKindSet({TypeKind.ARRAY}))
175 )
176 self.assertFalse(
177 TypeKindSet({TypeKind.POINTER}).isdisjoint(TypeKindSet({TypeKind.POINTER}))
178 )
179 self.assertFalse(
180 TypeKindSet({TypeKind.ARRAY}).isdisjoint(
181 TypeKindSet({TypeKind.POINTER, TypeKind.ARRAY})
182 )
183 )
184 self.assertFalse(
185 TypeKindSet({TypeKind.POINTER, TypeKind.ARRAY}).isdisjoint(
186 TypeKindSet({TypeKind.ARRAY})
187 )
188 )
189 self.assertTrue(TypeKindSet({TypeKind.POINTER}).isdisjoint({TypeKind.ARRAY}))
190 self.assertTrue(TypeKindSet({TypeKind.POINTER}).isdisjoint([TypeKind.ARRAY]))
191 self.assertFalse(TypeKindSet({TypeKind.POINTER}).isdisjoint({TypeKind.POINTER}))
192 self.assertFalse(TypeKindSet({TypeKind.POINTER}).isdisjoint([TypeKind.POINTER]))
193
194 def test_sub(self):
195 self.assertEqual(TypeKindSet() - TypeKindSet(), TypeKindSet())
196 self.assertEqual(
197 TypeKindSet({TypeKind.POINTER}) - TypeKindSet({TypeKind.ARRAY}),
198 TypeKindSet({TypeKind.POINTER}),
199 )
200 self.assertEqual(
201 TypeKindSet({TypeKind.POINTER}) - TypeKindSet({TypeKind.POINTER}),
202 TypeKindSet(),
203 )
204 self.assertEqual(
205 TypeKindSet({TypeKind.ARRAY})
206 - TypeKindSet({TypeKind.POINTER, TypeKind.ARRAY}),
207 TypeKindSet(),
208 )
209 self.assertEqual(
210 TypeKindSet({TypeKind.POINTER, TypeKind.ARRAY})
211 - TypeKindSet({TypeKind.ARRAY}),
212 TypeKindSet({TypeKind.POINTER}),
213 )
214 self.assertEqual(
215 TypeKindSet({TypeKind.POINTER, TypeKind.ARRAY}) - {TypeKind.ARRAY},
216 TypeKindSet({TypeKind.POINTER}),
217 )
218 self.assertEqual(
219 TypeKindSet({TypeKind.POINTER, TypeKind.ARRAY}) - {TypeKind.ARRAY, "asdf"},
220 TypeKindSet({TypeKind.POINTER}),
221 )
222
223 def test_and(self):
224 self.assertEqual(TypeKindSet() & TypeKindSet(), TypeKindSet())
225 self.assertEqual(
226 TypeKindSet({TypeKind.POINTER}) & TypeKindSet({TypeKind.ARRAY}),
227 TypeKindSet(),
228 )
229 self.assertEqual(
230 TypeKindSet({TypeKind.POINTER}) & TypeKindSet({TypeKind.POINTER}),
231 TypeKindSet({TypeKind.POINTER}),
232 )
233 self.assertEqual(
234 TypeKindSet({TypeKind.ARRAY})
235 & TypeKindSet({TypeKind.POINTER, TypeKind.ARRAY}),
236 TypeKindSet({TypeKind.ARRAY}),
237 )
238 self.assertEqual(
239 TypeKindSet({TypeKind.POINTER, TypeKind.ARRAY})
240 & TypeKindSet({TypeKind.ARRAY}),
241 TypeKindSet({TypeKind.ARRAY}),
242 )
243 self.assertEqual(
244 TypeKindSet({TypeKind.POINTER, TypeKind.ARRAY}) & {TypeKind.ARRAY},
245 TypeKindSet({TypeKind.ARRAY}),
246 )
247 self.assertEqual(
248 TypeKindSet({TypeKind.POINTER, TypeKind.ARRAY})
249 & {TypeKind.POINTER, "asdf"},
250 TypeKindSet({TypeKind.POINTER}),
251 )
252
253 def test_xor(self):
254 self.assertEqual(TypeKindSet() ^ TypeKindSet(), TypeKindSet())
255 self.assertEqual(
256 TypeKindSet({TypeKind.POINTER}) ^ TypeKindSet({TypeKind.ARRAY}),
257 TypeKindSet({TypeKind.POINTER, TypeKind.ARRAY}),
258 )
259 self.assertEqual(
260 TypeKindSet({TypeKind.POINTER}) ^ TypeKindSet({TypeKind.POINTER}),
261 TypeKindSet(),
262 )
263 self.assertEqual(
264 TypeKindSet({TypeKind.ARRAY})
265 ^ TypeKindSet({TypeKind.POINTER, TypeKind.ARRAY}),
266 TypeKindSet({TypeKind.POINTER}),
267 )
268 self.assertEqual(
269 TypeKindSet({TypeKind.POINTER, TypeKind.ARRAY})
270 ^ TypeKindSet({TypeKind.ARRAY}),
271 TypeKindSet({TypeKind.POINTER}),
272 )
273 self.assertEqual(
274 TypeKindSet({TypeKind.POINTER, TypeKind.ARRAY}) ^ {TypeKind.ARRAY},
275 TypeKindSet({TypeKind.POINTER}),
276 )
277 with self.assertRaises(TypeError):
278 TypeKindSet({TypeKind.POINTER, TypeKind.ARRAY}) ^ {TypeKind.ARRAY, "asdf"}
279
280 def test_or(self):
281 self.assertEqual(TypeKindSet() | TypeKindSet(), TypeKindSet())
282 self.assertEqual(
283 TypeKindSet({TypeKind.POINTER}) | TypeKindSet({TypeKind.ARRAY}),
284 TypeKindSet({TypeKind.POINTER, TypeKind.ARRAY}),
285 )
286 self.assertEqual(
287 TypeKindSet({TypeKind.POINTER}) | TypeKindSet({TypeKind.POINTER}),
288 TypeKindSet({TypeKind.POINTER}),
289 )
290 self.assertEqual(
291 TypeKindSet({TypeKind.ARRAY})
292 | TypeKindSet({TypeKind.POINTER, TypeKind.ARRAY}),
293 TypeKindSet({TypeKind.POINTER, TypeKind.ARRAY}),
294 )
295 self.assertEqual(
296 TypeKindSet({TypeKind.POINTER, TypeKind.ARRAY})
297 | TypeKindSet({TypeKind.ARRAY}),
298 TypeKindSet({TypeKind.POINTER, TypeKind.ARRAY}),
299 )
300 self.assertEqual(
301 TypeKindSet({TypeKind.POINTER}) | {TypeKind.ARRAY},
302 {TypeKind.POINTER, TypeKind.ARRAY},
303 )
304 with self.assertRaises(TypeError):
305 TypeKindSet({TypeKind.POINTER}) | {TypeKind.ARRAY, "asdf"}
306
307 def test_all_kinds(self):
308 self.assertEqual(set(TypeKindSet(TypeKind)), set(TypeKind))