Skip to content

Commit 1fa8e2f

Browse files
author
svorenova
committed
Adding unit test for generic fields
1 parent 398c88a commit 1fa8e2f

File tree

3 files changed

+242
-0
lines changed

3 files changed

+242
-0
lines changed

‎unit/java_bytecode/java_bytecode_parse_generics/GenericFields.class

1.09 KB
Binary file not shown.

‎unit/java_bytecode/java_bytecode_parse_generics/GenericFields.java

+17
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,17 @@
1+
public class GenericFields<T, S> {
2+
public T f;
3+
4+
public Generic<T> f2;
5+
public Generic<Integer> f3;
6+
7+
public Generic<Generic<T>> f4;
8+
public Generic<Generic<Generic<Integer>>> f5;
9+
10+
public GenericTwoParam<T, T> f6;
11+
public GenericTwoParam<T, S> f7;
12+
public GenericTwoParam<Integer, T> f8;
13+
public GenericTwoParam<T, Integer> f9;
14+
public GenericTwoParam<Integer, String> f10;
15+
16+
public GenericTwoParam<Generic<T>, GenericTwoParam<S, Integer>> f11;
17+
}

‎unit/java_bytecode/java_bytecode_parse_generics/parse_generic_fields.cpp

+225
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,225 @@
1+
/*******************************************************************\
2+
3+
Module: Unit tests for parsing generic classes
4+
5+
Author: DiffBlue Limited. All rights reserved.
6+
7+
\*******************************************************************/
8+
9+
#include <testing-utils/catch.hpp>
10+
#include <testing-utils/load_java_class.h>
11+
#include <testing-utils/require_symbol.h>
12+
#include <testing-utils/require_type.h>
13+
14+
#include <memory>
15+
16+
#include <util/config.h>
17+
#include <util/language.h>
18+
#include <java_bytecode/java_bytecode_language.h>
19+
20+
SCENARIO(
21+
"parse_generic_fields",
22+
"[core][java_bytecode][java_bytecode_parse_generics]")
23+
{
24+
const symbol_tablet &new_symbol_table = load_java_class(
25+
"GenericFields", "./java_bytecode/java_bytecode_parse_generics");
26+
27+
std::string class_prefix = "java::GenericFields";
28+
29+
WHEN("Parsing the class with generic fields")
30+
{
31+
THEN("There is a generic class symbol GenericField")
32+
{
33+
REQUIRE(new_symbol_table.has_symbol(class_prefix));
34+
35+
const symbolt &class_symbol = new_symbol_table.lookup_ref(class_prefix);
36+
const java_generics_class_typet &java_generics_class_type =
37+
require_type::require_java_generic_class(
38+
class_symbol.type, {class_prefix + "::T", class_prefix + "::S"});
39+
40+
const struct_typet class_struct = to_struct_type(class_symbol.type);
41+
42+
THEN("It has field f of type T")
43+
{
44+
const struct_union_typet::componentt &field =
45+
require_type::require_component(class_struct, "f");
46+
require_type::require_java_generic_parameter(
47+
field.type(),
48+
{require_type::type_parameter_kindt::Var, class_prefix + "::T"});
49+
}
50+
51+
THEN("It has field f2 pointing to Generic")
52+
{
53+
const struct_typet::componentt &field =
54+
require_type::require_component(class_struct, "f2");
55+
require_type::require_pointer(
56+
field.type(), symbol_typet("java::Generic"));
57+
THEN("The pointer should be generic")
58+
{
59+
require_type::require_java_generic_type(
60+
field.type(),
61+
{{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
62+
}
63+
}
64+
65+
THEN("It has field f3 pointing to Generic")
66+
{
67+
const struct_typet::componentt &field =
68+
require_type::require_component(class_struct, "f3");
69+
require_type::require_pointer(
70+
field.type(), symbol_typet("java::Generic"));
71+
THEN("The pointer should be generic")
72+
{
73+
require_type::require_java_generic_type(
74+
field.type(),
75+
{{require_type::type_parameter_kindt::Inst,
76+
"java::java"
77+
".lang.Integer"}});
78+
}
79+
}
80+
81+
THEN("It has field f3 pointing to Generic")
82+
{
83+
const struct_typet::componentt &field =
84+
require_type::require_component(class_struct, "f3");
85+
require_type::require_pointer(
86+
field.type(), symbol_typet("java::Generic"));
87+
THEN("The pointer should be generic")
88+
{
89+
require_type::require_java_generic_type(
90+
field.type(),
91+
{{require_type::type_parameter_kindt::Inst,
92+
"java::java"
93+
".lang.Integer"}});
94+
}
95+
}
96+
97+
THEN("It has field f4 pointing to Generic")
98+
{
99+
const struct_typet::componentt &field =
100+
require_type::require_component(class_struct, "f4");
101+
require_type::require_pointer(
102+
field.type(), symbol_typet("java::Generic"));
103+
THEN("The pointer should be generic")
104+
{
105+
require_type::require_java_generic_type(
106+
field.type(),
107+
{{require_type::type_parameter_kindt::Inst, "java::Generic"}});
108+
// TODO extend when nested generics are parsed correctly - TG-1301
109+
}
110+
}
111+
112+
THEN("It has field f5 pointing to Generic")
113+
{
114+
const struct_typet::componentt &field =
115+
require_type::require_component(class_struct, "f5");
116+
require_type::require_pointer(
117+
field.type(), symbol_typet("java::Generic"));
118+
THEN("The pointer should be generic")
119+
{
120+
require_type::require_java_generic_type(
121+
field.type(),
122+
{{require_type::type_parameter_kindt::Inst, "java::Generic"}});
123+
// TODO extend when nested generics are parsed correctly - TG-1301
124+
}
125+
}
126+
127+
THEN("It has field f6 pointing to GenericTwoParam")
128+
{
129+
const struct_typet::componentt &field =
130+
require_type::require_component(class_struct, "f6");
131+
require_type::require_pointer(
132+
field.type(), symbol_typet("java::GenericTwoParam"));
133+
THEN("The pointer should be generic")
134+
{
135+
require_type::require_java_generic_type(
136+
field.type(),
137+
{{require_type::type_parameter_kindt::Var, class_prefix + "::T"},
138+
{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
139+
}
140+
}
141+
142+
THEN("It has field f7 pointing to GenericTwoParam")
143+
{
144+
const struct_typet::componentt &field =
145+
require_type::require_component(class_struct, "f7");
146+
require_type::require_pointer(
147+
field.type(), symbol_typet("java::GenericTwoParam"));
148+
THEN("The pointer should be generic")
149+
{
150+
require_type::require_java_generic_type(
151+
field.type(),
152+
{{require_type::type_parameter_kindt::Var, class_prefix + "::T"},
153+
{require_type::type_parameter_kindt::Var, class_prefix + "::S"}});
154+
}
155+
}
156+
157+
THEN("It has field f8 pointing to GenericTwoParam")
158+
{
159+
const struct_typet::componentt &field =
160+
require_type::require_component(class_struct, "f8");
161+
require_type::require_pointer(
162+
field.type(), symbol_typet("java::GenericTwoParam"));
163+
THEN("The pointer should be generic")
164+
{
165+
require_type::require_java_generic_type(
166+
field.type(),
167+
{{require_type::type_parameter_kindt::Inst,
168+
"java::java.lang.Integer"},
169+
{require_type::type_parameter_kindt::Var, class_prefix + "::T"}});
170+
}
171+
}
172+
173+
THEN("It has field f9 pointing to GenericTwoParam")
174+
{
175+
const struct_typet::componentt &field =
176+
require_type::require_component(class_struct, "f9");
177+
require_type::require_pointer(
178+
field.type(), symbol_typet("java::GenericTwoParam"));
179+
THEN("The pointer should be generic")
180+
{
181+
require_type::require_java_generic_type(
182+
field.type(),
183+
{{require_type::type_parameter_kindt::Var, class_prefix + "::T"},
184+
{require_type::type_parameter_kindt::Inst,
185+
"java::java.lang"
186+
".Integer"}});
187+
}
188+
}
189+
190+
THEN("It has field f10 pointing to GenericTwoParam")
191+
{
192+
const struct_typet::componentt &field =
193+
require_type::require_component(class_struct, "f10");
194+
require_type::require_pointer(
195+
field.type(), symbol_typet("java::GenericTwoParam"));
196+
THEN("The pointer should be generic")
197+
{
198+
require_type::require_java_generic_type(
199+
field.type(),
200+
{{require_type::type_parameter_kindt::Inst,
201+
"java::java.lang.Integer"},
202+
{require_type::type_parameter_kindt::Inst,
203+
"java::java.lang.String"}});
204+
}
205+
}
206+
207+
THEN("It has field f11 pointing to GenericTwoParam")
208+
{
209+
const struct_typet::componentt &field =
210+
require_type::require_component(class_struct, "f11");
211+
require_type::require_pointer(
212+
field.type(), symbol_typet("java::GenericTwoParam"));
213+
THEN("The pointer should be generic")
214+
{
215+
require_type::require_java_generic_type(
216+
field.type(),
217+
{{require_type::type_parameter_kindt::Inst, "java::Generic"},
218+
{require_type::type_parameter_kindt::Inst,
219+
"java::GenericTwoParam"}});
220+
// TODO extend when nested generics are parsed correctly - TG-1301
221+
}
222+
}
223+
}
224+
}
225+
}

0 commit comments

Comments
 (0)