Skip to content

Commit

Permalink
Extended tests to verify the generic information is being parsed corr…
Browse files Browse the repository at this point in the history 
…ectly.
  • Loading branch information
thk123 committed Oct 26, 2017
1 parent 465a473 commit ee39620
Show file tree
Hide file tree
Showing 3 changed files with 137 additions and 35 deletions.
Binary file modified unit/java_bytecode/java_bytecode_parse_generics/GenericClass.class
View file
Binary file not shown.
5 changes: 1 addition & 4 deletions unit/java_bytecode/java_bytecode_parse_generics/GenericClass.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -26,10 +26,7 @@ class SameGenericParamInnerClass<T>

InnerClass field;
GenericInnerClass<Foo> field2;
SameGenericParamInnerClass<Foo> field3;

GenericInnerClass<T> field4;
SameGenericParamInnerClass<T> field5;
GenericInnerClass<T> field3;

void method(InnerClass input)
{
Expand Down
167 changes: 136 additions & 31 deletions unit/java_bytecode/java_bytecode_parse_generics/parse_generic_inner_class.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -45,7 +45,17 @@ SCENARIO(
require_type::require_pointer(
field_component.type(), symbol_typet("java::GenericClass$InnerClass"));

// TODO: then the generic type should be correctly stored
THEN("The pointer should be generic")
{
REQUIRE(is_java_generic_type(field_component.type()));
const auto &generic_variables =
to_java_generic_type(field_component.type()).generic_type_variables();
REQUIRE(generic_variables.size() == 1);
const java_generic_parametert &generic_param = generic_variables[0];
REQUIRE(
generic_param.type_variable() ==
symbol_typet("java::GenericClass::T"));
}
}

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

// TODO: then the generic type should be correctly stored
THEN("The pointer should be generic")
{
REQUIRE(is_java_generic_type(field_component.type()));
const auto &generic_variables =
to_java_generic_type(field_component.type()).generic_type_variables();
REQUIRE(generic_variables.size() == 2);
{
const java_generic_parametert &generic_param = generic_variables[0];
REQUIRE(is_java_generic_parameter(generic_param));
REQUIRE(
generic_param.type_variable() ==
symbol_typet("java::GenericClass::T"));
}
{
const java_generic_parametert &generic_param = generic_variables[1];
REQUIRE(is_java_generic_inst_parameter(generic_param));
REQUIRE(
generic_param ==
java_generic_inst_parametert(symbol_typet("java::Foo")));
}
}
}

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

require_type::require_pointer(
field_component.type(),
symbol_typet("java::GenericClass$SameGenericParamInnerClass"));

// TODO: then the generic type should be correctly stored
}

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

require_type::require_pointer(
field_component.type(),
symbol_typet("java::GenericClass$GenericInnerClass"));

// TODO: then the generic type should be correctly stored
}
THEN("The field component should be a pointer to GenericClass$InnerClass")
{
const struct_typet::componentt &field_component =
require_type::require_component(class_type, "field5");

require_type::require_pointer(
field_component.type(),
symbol_typet("java::GenericClass$SameGenericParamInnerClass"));

// TODO: then the generic type should be correctly stored
THEN("The pointer should be generic")
{
REQUIRE(is_java_generic_type(field_component.type()));
const auto &generic_variables =
to_java_generic_type(field_component.type()).generic_type_variables();
REQUIRE(generic_variables.size() == 2);
{
const java_generic_parametert &generic_param = generic_variables[0];
REQUIRE(is_java_generic_parameter(generic_param));
REQUIRE(
generic_param.type_variable() ==
symbol_typet("java::GenericClass::T"));
}
{
const java_generic_parametert &generic_param = generic_variables[1];
REQUIRE(is_java_generic_parameter(generic_param));
REQUIRE(
generic_param.type_variable() ==
symbol_typet("java::GenericClass::T"));
}
}
}
}

THEN("There should be a symbol for the generic inner class")
{
}
// TODO: add fields of doubly nested generic classes
}

SCENARIO(
Expand Down Expand Up @@ -254,6 +279,28 @@ SCENARIO(
require_type::require_parameter(function_call, "input");
require_type::require_pointer(
param_type.type(), symbol_typet("java::GenericClass$GenericInnerClass"));

THEN("The pointer should be generic")
{
REQUIRE(is_java_generic_type(param_type.type()));
const auto &generic_variables =
to_java_generic_type(param_type.type()).generic_type_variables();
REQUIRE(generic_variables.size() == 2);
{
const java_generic_parametert &generic_param = generic_variables[0];
REQUIRE(is_java_generic_parameter(generic_param));
REQUIRE(
generic_param.type_variable() ==
symbol_typet("java::GenericClass::T"));
}
{
const java_generic_parametert &generic_param = generic_variables[1];
REQUIRE(is_java_generic_parameter(generic_param));
REQUIRE(
generic_param.type_variable() ==
symbol_typet("java::GenericClass::T"));
}
}
}
THEN("Method 5 should return a GenericClass$InnerClass")
{
Expand All @@ -272,8 +319,20 @@ SCENARIO(
require_type::require_pointer(
function_call.return_type(),
symbol_typet("java::GenericClass$InnerClass"));

THEN("The pointer should be generic")
{
REQUIRE(is_java_generic_type(function_call.return_type()));
const auto &generic_variables =
to_java_generic_type(function_call.return_type())
.generic_type_variables();
REQUIRE(generic_variables.size() == 1);
const java_generic_parametert &generic_param = generic_variables[0];
REQUIRE(
generic_param.type_variable() == symbol_typet("java::GenericClass::T"));
}
}
THEN("Method 6 should return a GenericClass$InnerClass")
THEN("Method 6 should return a GenericClass$GenericInnerClass")
{
const std::string func_name = ".method6";
const std::string func_descriptor = ":()LGenericClass$GenericInnerClass;";
Expand All @@ -290,8 +349,31 @@ SCENARIO(
require_type::require_pointer(
function_call.return_type(),
symbol_typet("java::GenericClass$GenericInnerClass"));

THEN("The pointer should be generic")
{
REQUIRE(is_java_generic_type(function_call.return_type()));
const auto &generic_variables =
to_java_generic_type(function_call.return_type())
.generic_type_variables();
REQUIRE(generic_variables.size() == 2);
{
const java_generic_parametert &generic_param = generic_variables[0];
REQUIRE(is_java_generic_parameter(generic_param));
REQUIRE(
generic_param.type_variable() ==
symbol_typet("java::GenericClass::T"));
}
{
const java_generic_parametert &generic_param = generic_variables[1];
REQUIRE(is_java_generic_inst_parameter(generic_param));
REQUIRE(
generic_param ==
java_generic_inst_parametert(symbol_typet("java::Foo")));
}
}
}
THEN("Method 7 should return a GenericClass$InnerClass")
THEN("Method 7 should return a GenericClass$GenericInnerClass")
{
const std::string func_name = ".method7";
const std::string func_descriptor = ":()LGenericClass$GenericInnerClass;";
Expand All @@ -308,5 +390,28 @@ SCENARIO(
require_type::require_pointer(
function_call.return_type(),
symbol_typet("java::GenericClass$GenericInnerClass"));

THEN("The pointer should be generic")
{
REQUIRE(is_java_generic_type(function_call.return_type()));
const auto &generic_variables =
to_java_generic_type(function_call.return_type())
.generic_type_variables();
REQUIRE(generic_variables.size() == 2);
{
const java_generic_parametert &generic_param = generic_variables[0];
REQUIRE(is_java_generic_parameter(generic_param));
REQUIRE(
generic_param.type_variable() ==
symbol_typet("java::GenericClass::T"));
}
{
const java_generic_parametert &generic_param = generic_variables[1];
REQUIRE(is_java_generic_parameter(generic_param));
REQUIRE(
generic_param.type_variable() ==
symbol_typet("java::GenericClass::T"));
}
}
}
}

0 comments on commit ee39620

Please sign in to comment.