require_type.cpp

Go to the documentation of this file.

/*******************************************************************\
 
Module: Unit test utilities
 
Author: Diffblue Ltd.
 
\*******************************************************************/
 
#include "require_type.h"
 
#include <testing-utils/use_catch.h>
 
pointer_typet require_type::require_pointer(
  const typet &type,
  const std::optional<typet> &subtype)
{
  REQUIRE(type.id() == ID_pointer);
  const pointer_typet &pointer = to_pointer_type(type);
 
  if(subtype)
    REQUIRE(pointer.base_type() == subtype.value());
 
  return pointer;
}
 
java_class_typet::componentt require_type::require_component(
  const java_class_typet &java_class_type,
  const irep_idt &component_name)
{
  const auto &component = std::find_if(
    java_class_type.components().begin(),
    java_class_type.components().end(),
    [&component_name](const java_class_typet::componentt &component) {
      return component.get_name() == component_name;
    });
 
  REQUIRE(component != java_class_type.components().end());
  return *component;
}
 
struct_typet::componentt require_type::require_component(
  const struct_typet &struct_type,
  const irep_idt &component_name)
{
  const auto &componet = std::find_if(
    struct_type.components().begin(),
    struct_type.components().end(),
    [&component_name](const struct_union_typet::componentt &component) {
      return component.get_name() == component_name;
    });
 
  REQUIRE(componet != struct_type.components().end());
  return *componet;
}
 
code_typet require_type::require_code(const typet &type)
{
  REQUIRE(type.id() == ID_code);
  return to_code_type(type);
}
 
code_typet
require_type::require_code(const typet &type, const size_t num_params)
{
  code_typet code_type = require_code(type);
  REQUIRE(code_type.parameters().size() == num_params);
  return code_type;
}
 
java_method_typet require_type::require_java_method(const typet &type)
{
  REQUIRE(can_cast_type<java_method_typet>(type));
  return to_java_method_type(type);
}
 
java_method_typet
require_type::require_java_method(const typet &type, const size_t num_params)
{
  java_method_typet method_type = require_java_method(type);
  REQUIRE(method_type.parameters().size() == num_params);
  return method_type;
}
 
code_typet::parametert require_type::require_parameter(
  const code_typet &function_type,
  const irep_idt &param_name)
{
  const auto param = std::find_if(
    function_type.parameters().begin(),
    function_type.parameters().end(),
    [&param_name](const code_typet::parametert param) {
      return param.get_base_name() == param_name;
    });
 
  REQUIRE(param != function_type.parameters().end());
  return *param;
}
 
bool require_java_generic_type_argument_expectation(
  const reference_typet &type_argument,
  const require_type::expected_type_argumentt &expected)
{
  switch(expected.kind)
  {
  case require_type::type_argument_kindt::Var:
  {
    REQUIRE(is_java_generic_parameter(type_argument));
    java_generic_parametert parameter =
      to_java_generic_parameter(type_argument);
    REQUIRE(parameter.type_variable().get_identifier() == expected.description);
    return true;
  }
  case require_type::type_argument_kindt::Inst:
  {
    REQUIRE(!is_java_generic_parameter(type_argument));
    REQUIRE(
      to_struct_tag_type(to_pointer_type(type_argument).base_type())
        .get_identifier() == expected.description);
    return true;
  }
  }
  // Should be unreachable...
  REQUIRE(false);
  return false;
}
 
java_generic_typet require_type::require_java_generic_type(const typet &type)
{
  REQUIRE(is_java_generic_type(type));
  return to_java_generic_type(type);
}
 
java_generic_typet require_type::require_java_generic_type(
  const typet &type,
  const require_type::expected_type_argumentst &type_expectations)
{
  const java_generic_typet &generic_type =
    require_type::require_java_generic_type(type);
 
  const java_generic_typet::generic_type_argumentst &generic_type_arguments =
    generic_type.generic_type_arguments();
  REQUIRE(generic_type_arguments.size() == type_expectations.size());
  REQUIRE(
    std::equal(
      generic_type_arguments.begin(),
      generic_type_arguments.end(),
      type_expectations.begin(),
      require_java_generic_type_argument_expectation));
 
  return generic_type;
}
 
java_generic_parametert
require_type::require_java_generic_parameter(const typet &type)
{
  REQUIRE(is_java_generic_parameter(type));
  return to_java_generic_parameter(type);
}
 
java_generic_parametert require_type::require_java_generic_parameter(
  const typet &type,
  const irep_idt &parameter)
{
  const java_generic_parametert &generic_param =
    require_type::require_java_generic_parameter(type);
 
  REQUIRE(
    require_java_generic_type_argument_expectation(
      generic_param, {require_type::type_argument_kindt::Var, parameter}));
 
  return generic_param;
}
 
const typet &require_type::require_java_non_generic_type(
  const typet &type,
  const std::optional<struct_tag_typet> &expect_subtype)
{
  REQUIRE(!is_java_generic_parameter(type));
  REQUIRE(!is_java_generic_type(type));
  if(expect_subtype)
    REQUIRE(to_pointer_type(type).base_type() == expect_subtype.value());
  return type;
}
 
class_typet require_type::require_complete_class(const typet &class_type)
{
  REQUIRE(class_type.id() == ID_struct);
 
  const java_class_typet &java_class_type = to_java_class_type(class_type);
  REQUIRE(java_class_type.is_class());
  REQUIRE_FALSE(java_class_type.get_is_stub());
 
  return java_class_type;
}
 
class_typet require_type::require_incomplete_class(const typet &class_type)
{
  REQUIRE(class_type.id() == ID_struct);
 
  const java_class_typet &java_class_type = to_java_class_type(class_type);
  REQUIRE(java_class_type.is_class());
  REQUIRE(java_class_type.get_is_stub());
 
  return java_class_type;
}
 
java_generic_class_typet
require_type::require_java_generic_class(const typet &class_type)
{
  REQUIRE(class_type.id() == ID_struct);
 
  const class_typet &class_class_type = to_class_type(class_type);
  const java_class_typet &java_class_type =
    to_java_class_type(class_class_type);
 
  REQUIRE(is_java_generic_class_type(java_class_type));
  const java_generic_class_typet &java_generic_class_type =
    to_java_generic_class_type(java_class_type);
 
  return java_generic_class_type;
}
 
java_generic_class_typet require_type::require_java_generic_class(
  const typet &class_type,
  const std::initializer_list<irep_idt> &type_variables)
{
  const java_generic_class_typet java_generic_class_type =
    require_java_generic_class(class_type);
 
  const java_generic_class_typet::generic_typest &generic_type_vars =
    java_generic_class_type.generic_types();
  REQUIRE(generic_type_vars.size() == type_variables.size());
  REQUIRE(
    std::equal(
      type_variables.begin(),
      type_variables.end(),
      generic_type_vars.begin(),
      [](
        const irep_idt &type_var_name,
        const java_generic_parametert &param) { //NOLINT
        REQUIRE(is_java_generic_parameter(param));
        return param.type_variable().get_identifier() == type_var_name;
      }));
 
  return java_generic_class_type;
}
 
java_generic_class_typet
require_type::require_complete_java_generic_class(const typet &class_type)
{
  require_complete_class(class_type);
  return require_java_generic_class(class_type);
}
 
java_generic_class_typet require_type::require_complete_java_generic_class(
  const typet &class_type,
  const std::initializer_list<irep_idt> &type_variables)
{
  require_complete_java_generic_class(class_type);
  return require_java_generic_class(class_type, type_variables);
}
 
java_implicitly_generic_class_typet
require_type::require_java_implicitly_generic_class(const typet &class_type)
{
  REQUIRE(class_type.id() == ID_struct);
 
  const class_typet &class_class_type = to_class_type(class_type);
  const java_class_typet &java_class_type =
    to_java_class_type(class_class_type);
 
  REQUIRE(is_java_implicitly_generic_class_type(java_class_type));
  const java_implicitly_generic_class_typet
    &java_implicitly_generic_class_type =
      to_java_implicitly_generic_class_type(java_class_type);
 
  return java_implicitly_generic_class_type;
}
 
java_implicitly_generic_class_typet
require_type::require_java_implicitly_generic_class(
  const typet &class_type,
  const std::initializer_list<irep_idt> &implicit_type_variables)
{
  const java_implicitly_generic_class_typet
    &java_implicitly_generic_class_type =
      require_java_implicitly_generic_class(class_type);
 
  const java_implicitly_generic_class_typet::implicit_generic_typest
    &implicit_generic_type_vars =
      java_implicitly_generic_class_type.implicit_generic_types();
  REQUIRE(implicit_generic_type_vars.size() == implicit_type_variables.size());
  auto param = implicit_generic_type_vars.begin();
  auto type_var_name = implicit_type_variables.begin();
  for(; param != implicit_generic_type_vars.end(); ++param, ++type_var_name)
  {
    REQUIRE(is_java_generic_parameter(*param));
    REQUIRE(param->type_variable().get_identifier() == *type_var_name);
  }
  return java_implicitly_generic_class_type;
}
 
java_implicitly_generic_class_typet
require_type::require_complete_java_implicitly_generic_class(
  const typet &class_type)
{
  require_complete_class(class_type);
  return require_java_implicitly_generic_class(class_type);
}
 
java_implicitly_generic_class_typet
require_type::require_complete_java_implicitly_generic_class(
  const typet &class_type,
  const std::initializer_list<irep_idt> &implicit_type_variables)
{
  require_complete_class(class_type);
  return require_java_implicitly_generic_class(
    class_type, implicit_type_variables);
}
 
java_class_typet
require_type::require_java_non_generic_class(const typet &class_type)
{
  REQUIRE(class_type.id() == ID_struct);
 
  const class_typet &class_class_type = to_class_type(class_type);
  const java_class_typet &java_class_type =
    to_java_class_type(class_class_type);
 
  REQUIRE(!is_java_generic_class_type(java_class_type));
  REQUIRE(!is_java_implicitly_generic_class_type(java_class_type));
 
  return java_class_type;
}
 
java_class_typet
require_type::require_complete_java_non_generic_class(const typet &class_type)
{
  require_complete_class(class_type);
  return require_java_non_generic_class(class_type);
}
 
const struct_tag_typet &
require_type::require_struct_tag(const typet &type, const irep_idt &identifier)
{
  REQUIRE(type.id() == ID_struct_tag);
  const struct_tag_typet &result = to_struct_tag_type(type);
  if(!identifier.empty())
  {
    REQUIRE(result.get_identifier() == identifier);
  }
  return result;
}
 
pointer_typet
require_type::require_pointer_to_tag(const typet &type, const irep_idt &tag)
{
  const auto pointer_type = require_type::require_pointer(type, {});
  require_type::require_struct_tag(pointer_type.base_type(), tag);
  return pointer_type;
}
 
java_generic_struct_tag_typet
require_type::require_java_generic_struct_tag_type(
  const typet &type,
  const std::string &identifier)
{
  struct_tag_typet struct_tag_type = require_struct_tag(type, identifier);
  REQUIRE(is_java_generic_struct_tag_type(type));
  return to_java_generic_struct_tag_type(type);
}
 
java_generic_struct_tag_typet
require_type::require_java_generic_struct_tag_type(
  const typet &type,
  const std::string &identifier,
  const require_type::expected_type_argumentst &type_expectations)
{
  const java_generic_struct_tag_typet &generic_base_type =
    require_java_generic_struct_tag_type(type, identifier);
 
  const java_generic_typet::generic_type_argumentst &generic_type_arguments =
    generic_base_type.generic_types();
  REQUIRE(generic_type_arguments.size() == type_expectations.size());
  REQUIRE(
    std::equal(
      generic_type_arguments.begin(),
      generic_type_arguments.end(),
      type_expectations.begin(),
      require_java_generic_type_argument_expectation));
 
  return generic_base_type;
}
 
require_type::java_lambda_method_handlest
require_type::require_lambda_method_handles(
  const java_class_typet &class_type,
  const std::vector<std::string> &expected_identifiers)
{
  const require_type::java_lambda_method_handlest &lambda_method_handles =
    class_type.lambda_method_handles();
  REQUIRE(lambda_method_handles.size() == expected_identifiers.size());
 
  REQUIRE(std::equal(
    lambda_method_handles.begin(),
    lambda_method_handles.end(),
    expected_identifiers.begin(),
    [](
      const java_class_typet::java_lambda_method_handlet &lambda_method_handle,
      const std::string &expected_identifier) { //NOLINT
      return lambda_method_handle.get_lambda_method_descriptor()
               .get_identifier() == expected_identifier;
    }));
  return lambda_method_handles;
}