Skip to content

Commit ee39620

Browse files
author
thk123
committed
Extended tests to verify the generic information is being parsed correctly.
1 parent 465a473 commit ee39620

File tree

3 files changed

+137
-35
lines changed

3 files changed

+137
-35
lines changed

‎unit/java_bytecode/java_bytecode_parse_generics/GenericClass.class‎

-204 Bytes
Binary file not shown.

‎unit/java_bytecode/java_bytecode_parse_generics/GenericClass.java‎

Lines changed: 1 addition & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -26,10 +26,7 @@ class SameGenericParamInnerClass<T>
2626

2727
InnerClass field;
2828
GenericInnerClass<Foo> field2;
29-
SameGenericParamInnerClass<Foo> field3;
30-
31-
GenericInnerClass<T> field4;
32-
SameGenericParamInnerClass<T> field5;
29+
GenericInnerClass<T> field3;
3330

3431
void method(InnerClass input)
3532
{

‎unit/java_bytecode/java_bytecode_parse_generics/parse_generic_inner_class.cpp‎

Lines changed: 136 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -45,7 +45,17 @@ SCENARIO(
4545
require_type::require_pointer(
4646
field_component.type(), symbol_typet("java::GenericClass$InnerClass"));
4747

48-
// TODO: then the generic type should be correctly stored
48+
THEN("The pointer should be generic")
49+
{
50+
REQUIRE(is_java_generic_type(field_component.type()));
51+
const auto &generic_variables =
52+
to_java_generic_type(field_component.type()).generic_type_variables();
53+
REQUIRE(generic_variables.size() == 1);
54+
const java_generic_parametert &generic_param = generic_variables[0];
55+
REQUIRE(
56+
generic_param.type_variable() ==
57+
symbol_typet("java::GenericClass::T"));
58+
}
4959
}
5060

5161
THEN("The field component should be a pointer to GenericClass$InnerClass")
@@ -57,48 +67,63 @@ SCENARIO(
5767
field_component.type(),
5868
symbol_typet("java::GenericClass$GenericInnerClass"));
5969

60-
// TODO: then the generic type should be correctly stored
70+
THEN("The pointer should be generic")
71+
{
72+
REQUIRE(is_java_generic_type(field_component.type()));
73+
const auto &generic_variables =
74+
to_java_generic_type(field_component.type()).generic_type_variables();
75+
REQUIRE(generic_variables.size() == 2);
76+
{
77+
const java_generic_parametert &generic_param = generic_variables[0];
78+
REQUIRE(is_java_generic_parameter(generic_param));
79+
REQUIRE(
80+
generic_param.type_variable() ==
81+
symbol_typet("java::GenericClass::T"));
82+
}
83+
{
84+
const java_generic_parametert &generic_param = generic_variables[1];
85+
REQUIRE(is_java_generic_inst_parameter(generic_param));
86+
REQUIRE(
87+
generic_param ==
88+
java_generic_inst_parametert(symbol_typet("java::Foo")));
89+
}
90+
}
6191
}
6292

6393
THEN("The field component should be a pointer to GenericClass$InnerClass")
6494
{
6595
const struct_typet::componentt &field_component =
6696
require_type::require_component(class_type, "field3");
6797

68-
require_type::require_pointer(
69-
field_component.type(),
70-
symbol_typet("java::GenericClass$SameGenericParamInnerClass"));
71-
72-
// TODO: then the generic type should be correctly stored
73-
}
74-
75-
THEN("The field component should be a pointer to GenericClass$InnerClass")
76-
{
77-
const struct_typet::componentt &field_component =
78-
require_type::require_component(class_type, "field4");
79-
8098
require_type::require_pointer(
8199
field_component.type(),
82100
symbol_typet("java::GenericClass$GenericInnerClass"));
83101

84-
// TODO: then the generic type should be correctly stored
85-
}
86-
THEN("The field component should be a pointer to GenericClass$InnerClass")
87-
{
88-
const struct_typet::componentt &field_component =
89-
require_type::require_component(class_type, "field5");
90-
91-
require_type::require_pointer(
92-
field_component.type(),
93-
symbol_typet("java::GenericClass$SameGenericParamInnerClass"));
94-
95-
// TODO: then the generic type should be correctly stored
102+
THEN("The pointer should be generic")
103+
{
104+
REQUIRE(is_java_generic_type(field_component.type()));
105+
const auto &generic_variables =
106+
to_java_generic_type(field_component.type()).generic_type_variables();
107+
REQUIRE(generic_variables.size() == 2);
108+
{
109+
const java_generic_parametert &generic_param = generic_variables[0];
110+
REQUIRE(is_java_generic_parameter(generic_param));
111+
REQUIRE(
112+
generic_param.type_variable() ==
113+
symbol_typet("java::GenericClass::T"));
114+
}
115+
{
116+
const java_generic_parametert &generic_param = generic_variables[1];
117+
REQUIRE(is_java_generic_parameter(generic_param));
118+
REQUIRE(
119+
generic_param.type_variable() ==
120+
symbol_typet("java::GenericClass::T"));
121+
}
122+
}
96123
}
97124
}
98125

99-
THEN("There should be a symbol for the generic inner class")
100-
{
101-
}
126+
// TODO: add fields of doubly nested generic classes
102127
}
103128

104129
SCENARIO(
@@ -254,6 +279,28 @@ SCENARIO(
254279
require_type::require_parameter(function_call, "input");
255280
require_type::require_pointer(
256281
param_type.type(), symbol_typet("java::GenericClass$GenericInnerClass"));
282+
283+
THEN("The pointer should be generic")
284+
{
285+
REQUIRE(is_java_generic_type(param_type.type()));
286+
const auto &generic_variables =
287+
to_java_generic_type(param_type.type()).generic_type_variables();
288+
REQUIRE(generic_variables.size() == 2);
289+
{
290+
const java_generic_parametert &generic_param = generic_variables[0];
291+
REQUIRE(is_java_generic_parameter(generic_param));
292+
REQUIRE(
293+
generic_param.type_variable() ==
294+
symbol_typet("java::GenericClass::T"));
295+
}
296+
{
297+
const java_generic_parametert &generic_param = generic_variables[1];
298+
REQUIRE(is_java_generic_parameter(generic_param));
299+
REQUIRE(
300+
generic_param.type_variable() ==
301+
symbol_typet("java::GenericClass::T"));
302+
}
303+
}
257304
}
258305
THEN("Method 5 should return a GenericClass$InnerClass")
259306
{
@@ -272,8 +319,20 @@ SCENARIO(
272319
require_type::require_pointer(
273320
function_call.return_type(),
274321
symbol_typet("java::GenericClass$InnerClass"));
322+
323+
THEN("The pointer should be generic")
324+
{
325+
REQUIRE(is_java_generic_type(function_call.return_type()));
326+
const auto &generic_variables =
327+
to_java_generic_type(function_call.return_type())
328+
.generic_type_variables();
329+
REQUIRE(generic_variables.size() == 1);
330+
const java_generic_parametert &generic_param = generic_variables[0];
331+
REQUIRE(
332+
generic_param.type_variable() == symbol_typet("java::GenericClass::T"));
333+
}
275334
}
276-
THEN("Method 6 should return a GenericClass$InnerClass")
335+
THEN("Method 6 should return a GenericClass$GenericInnerClass")
277336
{
278337
const std::string func_name = ".method6";
279338
const std::string func_descriptor = ":()LGenericClass$GenericInnerClass;";
@@ -290,8 +349,31 @@ SCENARIO(
290349
require_type::require_pointer(
291350
function_call.return_type(),
292351
symbol_typet("java::GenericClass$GenericInnerClass"));
352+
353+
THEN("The pointer should be generic")
354+
{
355+
REQUIRE(is_java_generic_type(function_call.return_type()));
356+
const auto &generic_variables =
357+
to_java_generic_type(function_call.return_type())
358+
.generic_type_variables();
359+
REQUIRE(generic_variables.size() == 2);
360+
{
361+
const java_generic_parametert &generic_param = generic_variables[0];
362+
REQUIRE(is_java_generic_parameter(generic_param));
363+
REQUIRE(
364+
generic_param.type_variable() ==
365+
symbol_typet("java::GenericClass::T"));
366+
}
367+
{
368+
const java_generic_parametert &generic_param = generic_variables[1];
369+
REQUIRE(is_java_generic_inst_parameter(generic_param));
370+
REQUIRE(
371+
generic_param ==
372+
java_generic_inst_parametert(symbol_typet("java::Foo")));
373+
}
374+
}
293375
}
294-
THEN("Method 7 should return a GenericClass$InnerClass")
376+
THEN("Method 7 should return a GenericClass$GenericInnerClass")
295377
{
296378
const std::string func_name = ".method7";
297379
const std::string func_descriptor = ":()LGenericClass$GenericInnerClass;";
@@ -308,5 +390,28 @@ SCENARIO(
308390
require_type::require_pointer(
309391
function_call.return_type(),
310392
symbol_typet("java::GenericClass$GenericInnerClass"));
393+
394+
THEN("The pointer should be generic")
395+
{
396+
REQUIRE(is_java_generic_type(function_call.return_type()));
397+
const auto &generic_variables =
398+
to_java_generic_type(function_call.return_type())
399+
.generic_type_variables();
400+
REQUIRE(generic_variables.size() == 2);
401+
{
402+
const java_generic_parametert &generic_param = generic_variables[0];
403+
REQUIRE(is_java_generic_parameter(generic_param));
404+
REQUIRE(
405+
generic_param.type_variable() ==
406+
symbol_typet("java::GenericClass::T"));
407+
}
408+
{
409+
const java_generic_parametert &generic_param = generic_variables[1];
410+
REQUIRE(is_java_generic_parameter(generic_param));
411+
REQUIRE(
412+
generic_param.type_variable() ==
413+
symbol_typet("java::GenericClass::T"));
414+
}
415+
}
311416
}
312417
}

0 commit comments

Comments
 (0)