cprover
require_type.cpp
Go to the documentation of this file.
1 /*******************************************************************\
2 
3  Module: Unit test utilities
4 
5  Author: Diffblue Ltd.
6 
7 \*******************************************************************/
8 
9 #include "require_type.h"
10 
11 #include <testing-utils/catch.hpp>
12 #include <util/base_type.h>
13 #include <util/namespace.h>
14 #include <util/symbol_table.h>
15 
22  const typet &type,
23  const optionalt<typet> &subtype)
24 {
25  REQUIRE(type.id() == ID_pointer);
26  const pointer_typet &pointer = to_pointer_type(type);
27 
28  if(subtype)
29  {
31  base_type_eq(pointer.subtype(), subtype.value(), ns);
32  }
33  return pointer;
34 }
35 
41  const struct_typet &struct_type,
42  const irep_idt &component_name)
43 {
44  const auto &componet = std::find_if(
45  struct_type.components().begin(),
46  struct_type.components().end(),
47  [&component_name](const struct_union_typet::componentt &component) {
48  return component.get_name() == component_name;
49  });
50 
51  REQUIRE(componet != struct_type.components().end());
52  return *componet;
53 }
54 
59 {
60  REQUIRE(type.id() == ID_code);
61  return to_code_type(type);
62 }
63 
71 require_type::require_code(const typet &type, const size_t num_params)
72 {
73  code_typet code_type = require_code(type);
74  REQUIRE(code_type.parameters().size() == num_params);
75  return code_type;
76 }
77 
82 {
83  REQUIRE(can_cast_type<java_method_typet>(type));
84  return to_java_method_type(type);
85 }
86 
94 require_type::require_java_method(const typet &type, const size_t num_params)
95 {
96  java_method_typet method_type = require_java_method(type);
97  REQUIRE(method_type.parameters().size() == num_params);
98  return method_type;
99 }
100 
107  const code_typet &function_type,
108  const irep_idt &param_name)
109 {
110  const auto param = std::find_if(
111  function_type.parameters().begin(),
112  function_type.parameters().end(),
113  [&param_name](const code_typet::parametert param) {
114  return param.get_base_name() == param_name;
115  });
116 
117  REQUIRE(param != function_type.parameters().end());
118  return *param;
119 }
120 
127  const reference_typet &type_argument,
129 {
130  switch(expected.kind)
131  {
133  {
134  REQUIRE(is_java_generic_parameter((type_argument)));
135  java_generic_parametert parameter =
136  to_java_generic_parameter(type_argument);
137  REQUIRE(parameter.type_variable().get_identifier() == expected.description);
138  return true;
139  }
141  {
142  REQUIRE(!is_java_generic_parameter(type_argument));
143  REQUIRE(type_argument.subtype() == symbol_typet(expected.description));
144  return true;
145  }
146  }
147  // Should be unreachable...
148  REQUIRE(false);
149  return false;
150 }
151 
156 {
157  REQUIRE(is_java_generic_type(type));
158  return to_java_generic_type(type);
159 }
160 
174  const typet &type,
175  const require_type::expected_type_argumentst &type_expectations)
176 {
177  const java_generic_typet &generic_type =
179 
180  const java_generic_typet::generic_type_argumentst &generic_type_arguments =
181  generic_type.generic_type_arguments();
182  REQUIRE(generic_type_arguments.size() == type_expectations.size());
183  REQUIRE(
184  std::equal(
185  generic_type_arguments.begin(),
186  generic_type_arguments.end(),
187  type_expectations.begin(),
189 
190  return generic_type;
191 }
192 
198 {
199  REQUIRE(is_java_generic_parameter(type));
200  return to_java_generic_parameter(type);
201 }
202 
210  const typet &type,
211  const irep_idt &parameter)
212 {
213  const java_generic_parametert &generic_param =
215 
216  REQUIRE(
218  generic_param, {require_type::type_argument_kindt::Var, parameter}));
219 
220  return generic_param;
221 }
222 
229  const typet &type,
230  const optionalt<symbol_typet> &expect_subtype)
231 {
232  REQUIRE(!is_java_generic_parameter(type));
233  REQUIRE(!is_java_generic_type(type));
234  if(expect_subtype)
235  REQUIRE(type.subtype() == expect_subtype.value());
236  return type;
237 }
238 
243 {
244  REQUIRE(class_type.id() == ID_struct);
245 
246  const class_typet &class_class_type = to_class_type(class_type);
247  REQUIRE(class_class_type.is_class());
248  REQUIRE_FALSE(class_class_type.get_bool(ID_incomplete_class));
249 
250  return class_class_type;
251 }
252 
257 {
258  REQUIRE(class_type.id() == ID_struct);
259 
260  const class_typet &class_class_type = to_class_type(class_type);
261  REQUIRE(class_class_type.is_class());
262  REQUIRE(class_class_type.get_bool(ID_incomplete_class));
263 
264  return class_class_type;
265 }
266 
272 {
273  REQUIRE(class_type.id() == ID_struct);
274 
275  const class_typet &class_class_type = to_class_type(class_type);
276  const java_class_typet &java_class_type =
277  to_java_class_type(class_class_type);
278 
279  REQUIRE(is_java_generic_class_type(java_class_type));
280  const java_generic_class_typet &java_generic_class_type =
281  to_java_generic_class_type(java_class_type);
282 
283  return java_generic_class_type;
284 }
285 
292  const typet &class_type,
293  const std::initializer_list<irep_idt> &type_variables)
294 {
295  const java_generic_class_typet java_generic_class_type =
296  require_java_generic_class(class_type);
297 
298  const java_generic_class_typet::generic_typest &generic_type_vars =
299  java_generic_class_type.generic_types();
300  REQUIRE(generic_type_vars.size() == type_variables.size());
301  REQUIRE(
302  std::equal(
303  type_variables.begin(),
304  type_variables.end(),
305  generic_type_vars.begin(),
306  [](
307  const irep_idt &type_var_name,
308  const java_generic_parametert &param) { //NOLINT
309  REQUIRE(is_java_generic_parameter(param));
310  return param.type_variable().get_identifier() == type_var_name;
311  }));
312 
313  return java_generic_class_type;
314 }
315 
321 {
322  require_complete_class(class_type);
323  return require_java_generic_class(class_type);
324 }
325 
332  const typet &class_type,
333  const std::initializer_list<irep_idt> &type_variables)
334 {
336  return require_java_generic_class(class_type, type_variables);
337 }
338 
344 {
345  REQUIRE(class_type.id() == ID_struct);
346 
347  const class_typet &class_class_type = to_class_type(class_type);
348  const java_class_typet &java_class_type =
349  to_java_class_type(class_class_type);
350 
351  REQUIRE(is_java_implicitly_generic_class_type(java_class_type));
353  &java_implicitly_generic_class_type =
354  to_java_implicitly_generic_class_type(java_class_type);
355 
356  return java_implicitly_generic_class_type;
357 }
358 
366  const typet &class_type,
367  const std::initializer_list<irep_idt> &implicit_type_variables)
368 {
370  &java_implicitly_generic_class_type =
372 
374  &implicit_generic_type_vars =
375  java_implicitly_generic_class_type.implicit_generic_types();
376  REQUIRE(implicit_generic_type_vars.size() == implicit_type_variables.size());
377  REQUIRE(
378  std::equal(
379  implicit_type_variables.begin(),
380  implicit_type_variables.end(),
381  implicit_generic_type_vars.begin(),
382  [](
383  const irep_idt &type_var_name,
384  const java_generic_parametert &param) { //NOLINT
385  REQUIRE(is_java_generic_parameter(param));
386  return param.type_variable().get_identifier() == type_var_name;
387  }));
388 
389  return java_implicitly_generic_class_type;
390 }
391 
397  const typet &class_type)
398 {
399  require_complete_class(class_type);
400  return require_java_implicitly_generic_class(class_type);
401 }
402 
410  const typet &class_type,
411  const std::initializer_list<irep_idt> &implicit_type_variables)
412 {
413  require_complete_class(class_type);
415  class_type, implicit_type_variables);
416 }
417 
423 {
424  REQUIRE(class_type.id() == ID_struct);
425 
426  const class_typet &class_class_type = to_class_type(class_type);
427  const java_class_typet &java_class_type =
428  to_java_class_type(class_class_type);
429 
430  REQUIRE(!is_java_generic_class_type(java_class_type));
431  REQUIRE(!is_java_implicitly_generic_class_type(java_class_type));
432 
433  return java_class_type;
434 }
435 
441 {
442  require_complete_class(class_type);
443  return require_java_non_generic_class(class_type);
444 }
445 
450 const symbol_typet &
451 require_type::require_symbol(const typet &type, const irep_idt &identifier)
452 {
453  REQUIRE(type.id() == ID_symbol);
454  const symbol_typet &result = to_symbol_type(type);
455  if(identifier != "")
456  {
457  REQUIRE(result.get_identifier() == identifier);
458  }
459  return result;
460 }
461 
467  const typet &type,
468  const std::string &identifier)
469 {
470  symbol_typet symbol_type = require_symbol(type, identifier);
471  REQUIRE(is_java_generic_symbol_type(type));
472  return to_java_generic_symbol_type(type);
473 }
474 
489  const typet &type,
490  const std::string &identifier,
491  const require_type::expected_type_argumentst &type_expectations)
492 {
493  const java_generic_symbol_typet &generic_base_type =
494  require_java_generic_symbol_type(type, identifier);
495 
496  const java_generic_typet::generic_type_argumentst &generic_type_arguments =
497  generic_base_type.generic_types();
498  REQUIRE(generic_type_arguments.size() == type_expectations.size());
499  REQUIRE(
500  std::equal(
501  generic_type_arguments.begin(),
502  generic_type_arguments.end(),
503  type_expectations.begin(),
505 
506  return generic_base_type;
507 }
508 
517  const java_class_typet &class_type,
518  const std::vector<std::string> &expected_identifiers)
519 {
520  const require_type::java_lambda_method_handlest &lambda_method_handles =
521  class_type.lambda_method_handles();
522  REQUIRE(lambda_method_handles.size() == expected_identifiers.size());
523 
524  REQUIRE(
525  std::equal(
526  lambda_method_handles.begin(),
527  lambda_method_handles.end(),
528  expected_identifiers.begin(),
529  [](
530  const symbol_exprt &lambda_method_handle,
531  const std::string &expected_identifier) { //NOLINT
532  return lambda_method_handle.get_identifier() == expected_identifier;
533  }));
534  return lambda_method_handles;
535 }
The type of an expression.
Definition: type.h:22
java_generic_class_typet require_complete_java_generic_class(const typet &class_type)
Verify that a class is a complete, valid java generic class.
std::vector< java_generic_parametert > implicit_generic_typest
Definition: java_types.h:584
Base type of functions.
Definition: std_types.h:764
const java_lambda_method_handlest & lambda_method_handles() const
Definition: java_types.h:176
bool is_java_generic_symbol_type(const typet &type)
Definition: java_types.h:724
java_generic_symbol_typet require_java_generic_symbol_type(const typet &type, const std::string &identifier)
Verify a given type is a java generic symbol type.
bool base_type_eq(const typet &type1, const typet &type2, const namespacet &ns)
Definition: base_type.cpp:326
const java_generic_class_typet & to_java_generic_class_type(const java_class_typet &type)
Definition: java_types.h:517
const typet & require_java_non_generic_type(const typet &type, const optionalt< symbol_typet > &expect_subtype)
Test a type to ensure it is not a java generics type.
const code_typet & to_code_type(const typet &type)
Cast a generic typet to a code_typet.
Definition: std_types.h:993
bool is_java_generic_parameter(const typet &type)
Checks whether the type is a java generic parameter/variable, e.g., T in List<T>. ...
Definition: java_types.h:392
const irep_idt & get_identifier() const
Definition: std_expr.h:128
const symbol_typet & to_symbol_type(const typet &type)
Cast a generic typet to a symbol_typet.
Definition: std_types.h:139
const java_generic_parametert & to_java_generic_parameter(const typet &type)
Definition: java_types.h:399
const componentst & components() const
Definition: std_types.h:245
java_implicitly_generic_class_typet require_complete_java_implicitly_generic_class(const typet &class_type)
Verify that a class is a complete, valid java implicitly generic class.
const class_typet & to_class_type(const typet &type)
Cast a generic typet to a class_typet.
Definition: std_types.h:435
Structure type.
Definition: std_types.h:297
java_lambda_method_handlest require_lambda_method_handles(const java_class_typet &class_type, const std::vector< std::string > &expected_identifiers)
Verify that the lambda method handles of a class match the given expectation.
std::initializer_list< expected_type_argumentt > expected_type_argumentst
Definition: require_type.h:58
java_class_typet::java_lambda_method_handlest java_lambda_method_handlest
Definition: require_type.h:123
const generic_type_argumentst & generic_type_arguments() const
Definition: java_types.h:441
const irep_idt & id() const
Definition: irep.h:259
const java_generic_symbol_typet & to_java_generic_symbol_type(const typet &type)
Definition: java_types.h:732
const type_variablet & type_variable() const
Definition: java_types.h:358
std::vector< reference_typet > generic_type_argumentst
Definition: java_types.h:432
Class to hold a class with generics, extends the java class type with a vector of java generic type p...
Definition: java_types.h:486
A reference into the symbol table.
Definition: std_types.h:110
java_generic_parametert require_java_generic_parameter(const typet &type)
Verify a given type is a java_generic_parameter, e.g., T
The pointer type.
Definition: std_types.h:1435
java_method_typet require_java_method(const typet &type)
Checks a type is a java_method_typet (i.e.
nonstd::optional< T > optionalt
Definition: optional.h:35
const java_implicitly_generic_class_typet & to_java_implicitly_generic_class_type(const java_class_typet &type)
Definition: java_types.h:622
java_implicitly_generic_class_typet require_java_implicitly_generic_class(const typet &class_type)
Verify that a class is a valid java implicitly generic class.
class_typet require_complete_class(const typet &class_type)
Checks that the given type is a complete class.
const symbol_typet & require_symbol(const typet &type, const irep_idt &identifier="")
Verify a given type is a symbol type, optionally with a specific identifier.
The symbol table.
Definition: symbol_table.h:19
TO_BE_DOCUMENTED.
Definition: namespace.h:74
java_generic_typet require_java_generic_type(const typet &type)
Verify a given type is a java_generic_type.
java_class_typet require_complete_java_non_generic_class(const typet &class_type)
Verify that a class is a complete, valid nongeneric java class.
const generic_typest & generic_types() const
Definition: java_types.h:708
bool is_java_generic_class_type(const typet &type)
Definition: java_types.h:509
symbol_exprt require_symbol(const exprt &expr, const irep_idt &symbol_name)
Verify a given exprt is an symbol_exprt with a identifier name equal to the symbol_name.
Type for a generic symbol, extends symbol_typet with a vector of java generic types.
Definition: java_types.h:698
bool can_cast_type< java_method_typet >(const typet &type)
Definition: java_types.h:284
java_generic_class_typet require_java_generic_class(const typet &class_type)
Verify that a class is a valid java generic class.
dstringt has one field, an unsigned integer no which is an index into a static table of strings...
Definition: dstring.h:33
const implicit_generic_typest & implicit_generic_types() const
Definition: java_types.h:598
Author: Diffblue Ltd.
code_typet::parametert require_parameter(const code_typet &function_type, const irep_idt &param_name)
Verify that a function has a parameter of a specific name.
java_class_typet require_java_non_generic_class(const typet &class_type)
Verify that a class is a valid nongeneric java class.
The reference type.
Definition: std_types.h:1492
Class to hold type with generic type arguments, for example java.util.List in either a reference of t...
Definition: java_types.h:429
const java_generic_typet & to_java_generic_type(const typet &type)
Definition: java_types.h:464
const java_method_typet & to_java_method_type(const typet &type)
Definition: java_types.h:289
const parameterst & parameters() const
Definition: std_types.h:905
pointer_typet require_pointer(const typet &type, const optionalt< typet > &subtype)
Checks a type is a pointer type optionally with a specific subtype.
Class to hold a Java generic type parameter (also called type variable), e.g., T in List<T>...
Definition: java_types.h:343
code_typet require_code(const typet &type)
Checks a type is a code_type (i.e.
Expression to hold a symbol (variable)
Definition: std_expr.h:90
bool is_java_generic_type(const typet &type)
Definition: java_types.h:457
const pointer_typet & to_pointer_type(const typet &type)
Cast a generic typet to a pointer_typet.
Definition: std_types.h:1459
class_typet require_incomplete_class(const typet &class_type)
Checks that the given type is an incomplete class.
Base Type Computation.
const typet & subtype() const
Definition: type.h:33
C++ class type.
Definition: std_types.h:341
struct_typet::componentt require_component(const struct_typet &struct_type, const irep_idt &component_name)
Checks a struct like type has a component with a specific name.
bool is_java_implicitly_generic_class_type(const typet &type)
Definition: java_types.h:614
Type to hold a Java class that is implicitly generic, e.g., an inner class of a generic outer class o...
Definition: java_types.h:581
Helper functions for requiring specific types If the type is of the wrong type, throw a CATCH excepti...
const java_class_typet & to_java_class_type(const typet &type)
Definition: java_types.h:227
const irep_idt & get_identifier() const
Definition: std_types.h:123
const generic_typest & generic_types() const
Definition: java_types.h:496
bool require_java_generic_type_argument_expectation(const reference_typet &type_argument, const require_type::expected_type_argumentt &expected)
Helper function for testing that java generic type arguments match a given expectation.
std::vector< java_generic_parametert > generic_typest
Definition: java_types.h:489