def test_convert_union_to_json_type(self):
union = {'u': Union('u')}
types = {}
convert_unions_to_type_for_json(union, types)
self.assertEqual(types, {UnionType('u').type_hash: UnionType('u')})
def test_parse_nested_union_without_name_to_type_for_json(self):
union = 'union s1{ union { char c; }s2; };'
types = {}
union = parse_struct(union, 'file')
parse_union_to_type_for_json(union, types)
prim = PrimitiveType('char')
s1 = UnionType('s1', [])
s2 = UnionType('_LOCAL_s1_s2', [])
expected = {prim.type_hash: prim, s1.type_hash: s1, s2.type_hash: s2}
self.assertEqual(types, expected)
def test_parse_nested_union_without_name_to_type_for_json_use_typedefed_name(
self):
union = 'typedef union { union { char c; }s2; } Tunion;'
types = {}
union = parse_union(union, 'file')
parse_union_to_type_for_json(union, types)
prim = PrimitiveType('char')
s1 = UnionType('_TYPEDEF_Tunion', [])
s2 = UnionType('_LOCAL_Tunion_s2', [])
tdef = TypedefedType('Tunion', s1)
expected = {
prim.type_hash: prim,
s1.type_hash: s1,
s2.type_hash: s2,
tdef.type_hash: tdef
}
self.assertEqual(types, expected)
def test_parse_typedef_to_union_without_name_to_type_for_json(self):
types = {}
union = 'typedef union {} type_s;'
s_info = parse_union(union, 'file')
parse_union_to_type_for_json(s_info, types)
st = UnionType('_TYPEDEF_type_s', [])
typedef = TypedefedType('type_s', st)
expected = {st.type_hash: st, typedef.type_hash: typedef}
self.assertEqual(types, expected)
def test_parse_union_to_type_for_json(self):
types = {}
union = 'union xy { int a;};'
s_info = parse_union(union, 'file')
parse_union_to_type_for_json(s_info, types)
st = UnionType('xy', [])
pt = PrimitiveType('int')
expected = {st.type_hash: st, pt.type_hash: pt}
self.assertEqual(types, expected)
def test_parse_typedef_ptr_to_union_to_type_for_json(self):
types = {}
union = 'typedef union xy {} *ptr_s;'
s_info = parse_union(union, 'file')
parse_union_to_type_for_json(s_info, types)
st = UnionType('xy', [])
ptr = PointerType(st)
typedef = TypedefedType('ptr_s', ptr)
expected = {
st.type_hash: st,
ptr.type_hash: ptr,
typedef.type_hash: typedef
}
self.assertEqual(types, expected)
def test_union_with_func_ptr_to_type_for_json(self):
types = {}
union = 'union s{int *(* ptr)();};'
s_info = parse_union(union, 'file')
parse_union_to_type_for_json(s_info, types)
tint = PrimitiveType('int')
ptrint = PointerType(tint)
func = FunctionType(ptrint, [])
func_ptr = PointerType(func)
st = UnionType('s', [func_ptr])
expected = {
tint.type_hash: tint,
ptrint.type_hash: ptrint,
func.type_hash: func,
func_ptr.type_hash: func_ptr,
st.type_hash: st
}
self.assertEqual(types, expected)
def test_union_type_correct_string_repr(self):
self.assertEqual(
UnionType('File').__repr__(), "UnionType('union File', [])")
def test_union_in_params_is_union_type(self):
self.assertEqual(parse_type_to_type_for_json('union uname', {}),
UnionType('uname'))
def test_has_members_returns_true_if_union_has_some_data(self):
self.assertTrue(
UnionType('s',
[Param('x',
PrimitiveType('int').type_hash)]).has_members)