Skip to content

Commit 398c88a

Browse files
author
svorenova
committed
Applying new utility functions for generics
1 parent cce7814 commit 398c88a

11 files changed

+1195
-2342
lines changed

‎unit/java_bytecode/java_bytecode_parse_generics/parse_bounded_generic_inner_classes.cpp

+75-144
Original file line numberDiff line numberDiff line change
@@ -8,11 +8,8 @@
88

99
#include <testing-utils/catch.hpp>
1010
#include <testing-utils/load_java_class.h>
11-
#include <testing-utils/require_symbol.h>
1211
#include <testing-utils/require_type.h>
1312

14-
#include <memory>
15-
1613
#include <util/config.h>
1714
#include <util/language.h>
1815
#include <java_bytecode/java_bytecode_language.h>
@@ -28,36 +25,29 @@ SCENARIO(
2825
std::string class_prefix = "java::BoundedGenericInnerClasses";
2926
REQUIRE(new_symbol_table.has_symbol(class_prefix));
3027

28+
const symbolt &class_symbol = new_symbol_table.lookup_ref(class_prefix);
29+
const java_class_typet &java_class_type =
30+
require_type::require_java_non_generic_class(class_symbol.type);
31+
3132
WHEN("Parsing an inner class with type variable")
3233
{
3334
std::string inner_name = class_prefix + "$Inner";
3435
REQUIRE(new_symbol_table.has_symbol(inner_name));
3536
THEN("The symbol type should be generic")
3637
{
3738
const symbolt &class_symbol = new_symbol_table.lookup_ref(inner_name);
38-
class_typet class_type =
39-
require_symbol::require_complete_class(class_symbol);
40-
java_generics_class_typet java_generics_class_type =
41-
require_type::require_java_generic_class(class_type);
42-
43-
const typet &elem_type =
44-
to_java_class_type(class_type).component_type("elem");
45-
REQUIRE(is_java_generic_parameter(elem_type));
39+
const java_generics_class_typet &java_generics_class_type =
40+
require_type::require_java_generic_class(
41+
class_symbol.type, {inner_name + "::E"});
4642

47-
REQUIRE(java_generics_class_type.generic_types().size() == 1);
48-
THEN("Type variable is named 'E'")
43+
THEN("The fields are of correct types")
4944
{
50-
typet &type_var = java_generics_class_type.generic_types().front();
51-
REQUIRE(is_java_generic_parameter(type_var));
52-
java_generic_parametert generic_type_var =
53-
to_java_generic_parameter(type_var);
54-
REQUIRE(
55-
generic_type_var.type_variable().get_identifier() ==
56-
inner_name + "::E");
57-
typet &sub_type = generic_type_var.subtype();
58-
REQUIRE(sub_type.id() == ID_symbol);
59-
symbol_typet &bound_type = to_symbol_type(sub_type);
60-
REQUIRE(bound_type.get_identifier() == "java::java.lang.Object");
45+
const struct_union_typet::componentt &elem =
46+
require_type::require_component(
47+
to_struct_type(class_symbol.type), "elem");
48+
require_type::require_java_generic_parameter(
49+
elem.type(),
50+
{require_type::type_parameter_kindt::Var, inner_name + "::E"});
6151
}
6252
}
6353
}
@@ -70,157 +60,98 @@ SCENARIO(
7060
{
7161
const symbolt &class_symbol =
7262
new_symbol_table.lookup_ref(boundedinner_name);
73-
class_typet class_type =
74-
require_symbol::require_complete_class(class_symbol);
75-
java_generics_class_typet java_generics_class_type =
76-
require_type::require_java_generic_class(class_type);
77-
78-
REQUIRE(java_generics_class_type.generic_types().size() == 1);
79-
typet &type_var = java_generics_class_type.generic_types().front();
80-
REQUIRE(is_java_generic_parameter(type_var));
81-
java_generic_parametert generic_type_var =
82-
to_java_generic_parameter(type_var);
83-
84-
REQUIRE(
85-
generic_type_var.type_variable().get_identifier() ==
86-
boundedinner_name + "::NUM");
87-
REQUIRE(
88-
java_generics_class_type_var(0, java_generics_class_type) ==
89-
boundedinner_name + "::NUM");
90-
THEN("Bound must be Number")
63+
const java_generics_class_typet &java_generics_class_type =
64+
require_type::require_java_generic_class(
65+
class_symbol.type, {boundedinner_name + "::NUM"});
66+
67+
//TODO extend when bounds are parsed correctly - TG-1286
68+
69+
THEN("The fields are of correct types")
9170
{
92-
typet &sub_type = generic_type_var.subtype();
93-
REQUIRE(sub_type.id() == ID_symbol);
94-
symbol_typet &bound_type = to_symbol_type(sub_type);
95-
REQUIRE(bound_type.get_identifier() == "java::java.lang.Number");
96-
REQUIRE(
97-
to_symbol_type(
98-
java_generics_class_type_bound(0, java_generics_class_type))
99-
.get_identifier() == "java::java.lang.Number");
71+
const struct_union_typet::componentt &elem =
72+
require_type::require_component(
73+
to_struct_type(class_symbol.type), "elem");
74+
require_type::require_java_generic_parameter(
75+
elem.type(),
76+
{require_type::type_parameter_kindt::Var,
77+
boundedinner_name + "::NUM"});
10078
}
101-
102-
const typet &elem_type =
103-
to_java_class_type(class_type).component_type("elem");
104-
REQUIRE(is_java_generic_parameter(elem_type));
10579
}
10680
}
10781

10882
WHEN("There is a generic field with a concrete type")
10983
{
110-
const symbolt &class_symbol = new_symbol_table.lookup_ref(class_prefix);
111-
class_typet class_type =
112-
require_symbol::require_complete_class(class_symbol);
113-
114-
java_class_typet java_class_type = to_java_class_type(class_type);
115-
REQUIRE(!is_java_generics_class_type(java_class_type));
116-
117-
const typet &belem_type = java_class_type.component_type("belem");
118-
119-
REQUIRE(belem_type != nil_typet());
120-
REQUIRE(is_java_generic_type(belem_type));
121-
THEN("Field has instantiated type variable")
122-
{
123-
const java_generic_typet &container = to_java_generic_type(belem_type);
124-
125-
const std::vector<java_generic_parametert> &generic_types =
126-
container.generic_type_variables();
127-
REQUIRE(generic_types.size() == 1);
128-
129-
const typet &inst_type = java_generic_get_inst_type(0, container);
130-
131-
REQUIRE(inst_type.id() == ID_pointer);
132-
const typet &inst_type_symbol = inst_type.subtype();
133-
REQUIRE(inst_type_symbol.id() == ID_symbol);
134-
REQUIRE(
135-
to_symbol_type(inst_type_symbol).get_identifier() ==
136-
"java::java.lang.Integer");
137-
}
84+
const struct_union_typet::componentt &belem_type =
85+
require_type::require_component(
86+
to_struct_type(class_symbol.type), "belem");
87+
require_type::require_pointer(
88+
belem_type.type(), symbol_typet(class_prefix + "$BoundedInner"));
89+
require_type::require_java_generic_type(
90+
belem_type.type(),
91+
{{require_type::type_parameter_kindt::Inst, "java::java.lang.Integer"}});
13892
}
13993

14094
WHEN("Parsing an inner class with double bounded type variable")
14195
{
14296
std::string doubleboundedinner_name = class_prefix + "$DoubleBoundedInner";
14397
REQUIRE(new_symbol_table.has_symbol(doubleboundedinner_name));
144-
THEN("The bounds should be encoded")
98+
THEN("The symbol type should be generic")
14599
{
146100
const symbolt &class_symbol =
147101
new_symbol_table.lookup_ref(doubleboundedinner_name);
148-
class_typet class_type =
149-
require_symbol::require_complete_class(class_symbol);
150-
151-
java_class_typet java_class_type = to_java_class_type(class_type);
152-
REQUIRE_FALSE(is_java_generics_class_type(java_class_type));
153-
154-
// TODO (tkiley): Extend this unit test when bounds are correctly
155-
// parsed - issue TG-1286
156-
#if 0
157-
java_generics_class_typet java_generics_class_type=
158-
to_java_generics_class_type(java_class_type);
159-
REQUIRE(java_generics_class_type.generic_types().size()==1);
160-
typet &type_var=java_generics_class_type.generic_types().front();
161-
REQUIRE(is_java_generic_parameter(type_var));
162-
java_generic_parametert generic_type_var=
163-
to_java_generic_parameter(type_var);
164-
165-
REQUIRE(
166-
generic_type_var.type_variable().get_identifier()==
167-
doubleboundedinner_name+"::T");
168-
REQUIRE(
169-
java_generics_class_type_var(0, java_generics_class_type)==
170-
doubleboundedinner_name+"::T");
171-
THEN("Bound must be Number and Interface")
172-
{
102+
const java_generics_class_typet &java_generics_class_type =
103+
require_type::require_java_generic_class(
104+
class_symbol.type, {doubleboundedinner_name + "::T"});
173105

106+
//TODO extend when bounds are parsed correctly - TG-1286
107+
108+
THEN("The fields are of correct types")
109+
{
110+
const struct_union_typet::componentt &elem =
111+
require_type::require_component(
112+
to_struct_type(class_symbol.type), "elem");
113+
require_type::require_java_generic_parameter(
114+
elem.type(),
115+
{require_type::type_parameter_kindt::Var,
116+
doubleboundedinner_name + "::T"});
117+
118+
// TODO extend when bounds are parsed correctly - TG-1286
174119
}
175-
#endif
176120
}
177121
}
178122

179123
GIVEN("An inner class with multiple generic parameters")
180124
{
181125
std::string twoelementinner_name = class_prefix + "$TwoElementInner";
182126
REQUIRE(new_symbol_table.has_symbol(twoelementinner_name));
183-
THEN("Both generic parameters should be encoded")
127+
THEN("The symbol type should be generic with two type variables")
184128
{
185129
const symbolt &class_symbol =
186130
new_symbol_table.lookup_ref(twoelementinner_name);
187-
class_typet class_type =
188-
require_symbol::require_complete_class(class_symbol);
189-
java_generics_class_typet java_generics_class_type =
190-
require_type::require_java_generic_class(class_type);
191-
192-
REQUIRE(java_generics_class_type.generic_types().size() == 2);
131+
const java_generics_class_typet &java_generics_class_type =
132+
require_type::require_java_generic_class(
133+
class_symbol.type,
134+
{twoelementinner_name + "::K", twoelementinner_name + "::V"});
193135

194-
// The first parameter should be called K
195-
{
196-
const typet first_param =
197-
java_generics_class_type.generic_types().at(0);
198-
REQUIRE(is_java_generic_parameter(first_param));
199-
java_generic_parametert generic_type_var =
200-
to_java_generic_parameter(first_param);
201-
202-
REQUIRE(
203-
generic_type_var.type_variable().get_identifier() ==
204-
twoelementinner_name + "::K");
205-
REQUIRE(
206-
java_generics_class_type_var(0, java_generics_class_type) ==
207-
twoelementinner_name + "::K");
208-
}
136+
//TODO extend when bounds are parsed correctly - TG-1286
209137

210-
// The second parameter should be called V
138+
THEN("The fields are of correct types")
211139
{
212-
const typet &second_param =
213-
java_generics_class_type.generic_types().at(1);
214-
REQUIRE(is_java_generic_parameter(second_param));
215-
java_generic_parametert generic_type_var =
216-
to_java_generic_parameter(second_param);
217-
218-
REQUIRE(
219-
generic_type_var.type_variable().get_identifier() ==
220-
twoelementinner_name + "::V");
221-
REQUIRE(
222-
java_generics_class_type_var(1, java_generics_class_type) ==
223-
twoelementinner_name + "::V");
140+
const struct_union_typet::componentt &elemk =
141+
require_type::require_component(
142+
to_struct_type(class_symbol.type), "k");
143+
require_type::require_java_generic_parameter(
144+
elemk.type(),
145+
{require_type::type_parameter_kindt::Var,
146+
twoelementinner_name + "::K"});
147+
148+
const struct_union_typet::componentt &elemv =
149+
require_type::require_component(
150+
to_struct_type(class_symbol.type), "v");
151+
require_type::require_java_generic_parameter(
152+
elemv.type(),
153+
{require_type::type_parameter_kindt::Var,
154+
twoelementinner_name + "::V"});
224155
}
225156
}
226157
}

‎unit/java_bytecode/java_bytecode_parse_generics/parse_derived_generic_class.cpp

+2-3
Original file line numberDiff line numberDiff line change
@@ -8,13 +8,11 @@
88

99
#include <testing-utils/catch.hpp>
1010
#include <testing-utils/load_java_class.h>
11-
#include <testing-utils/require_symbol.h>
12-
13-
#include <memory>
1411

1512
#include <util/config.h>
1613
#include <util/language.h>
1714
#include <java_bytecode/java_bytecode_language.h>
15+
#include <iostream>
1816

1917
SCENARIO(
2018
"parse_derived_generic_class",
@@ -29,6 +27,7 @@ SCENARIO(
2927
REQUIRE(new_symbol_table.has_symbol(class_prefix));
3028

3129
const symbolt &derived_symbol = new_symbol_table.lookup_ref(class_prefix);
30+
derived_symbol.show(std::cout);
3231
const class_typet &derived_class_type =
3332
require_symbol::require_complete_class(derived_symbol);
3433

0 commit comments

Comments
 (0)