All Classes and Interfaces
Class
Description
Represent an abstract proximitiy operation.
info about if the field is public
and if not, how to get/set value
Represent $all operation.
Represents a selector for the MongoDB `$all` operator
Represents a logical AND of multiple conditions.
Represents a CQL AND operation.
Logical AND operation over multiple DynamoDB query conditions.
Represent $and operation.
Represents a selector for the MongoDB `$and` operator
The any-label wildcard % in a label expression, e.g.
An operand that is an arithmetic expression over other operands, e.g.
The arithmetic connectives an
ArithmeticOperand can carry.array param
Parser for DynamoDB
BatchGetItem requests.DynamoDB
begins_with(path, value) predicate operation.DynamoDB
path BETWEEN lower AND upper predicate operation.info for JDK:
BigInteger constructors and operations throw ArithmeticException when the result is
out of the supported range of -2^Integer.MAX_VALUE (exclusive) to +2^Integer.MAX_VALUE (exclusive).
Represents a $bitsAllClear operation.
{ field: { $bitsAllClear: value } }
Represents a $bitsAllSet operation.
{ field: { $bitsAllSet: value } }
Represents a $bitsAnyClear operation.
{ field: { $bitsAnyClear: value } }
Represents a $bitsAnySet operation.
{ field: { $bitsAnySet: value } }
Base class for bitwise query operations.
boolean param
this is created for handling binary in thrift, see https://thrift.apache.org/docs/types
handle it as string
a type schema for java.nio.ByteBuffer
byte param
DSL (Domain Specific Language) for insertion operations on
a Cassandra database.
Acts upon CQL commands executed by the SUT against a Cassandra database.
Calculator designed to compute a branch-distance-based heuristic for a CQL (Cassandra Query Language) query,
given the rows returned by executing that query against the database.
Computes CQL-heuristics
Truthness for a CqlQueryOperation against a
candidate CassandraRow, i.e. how close the row comes to satisfying the query's
WHERE-clause condition(s).A single row of a Cassandra table, keyed by column name.
Class used to execute Cassandra insertions built with
CassandraDsl.char param
a set of util for generating instance creation and assertion with java in tests
in order to make endpoint invocation
collection param
collection type which includes Array, List, Set
A comparison from a WHERE clause: left OP right.
Represents a comparison operation.
Base class for comparison operations over a field and value.
Comparison operators used in Cypher WHERE clauses.
Represents a CQL CONTAINS KEY operation.
Represents a CQL CONTAINS operation.
DynamoDB
contains(path, value) predicate operation.Pairs a CQL command with its computed heuristic distance.
The heuristic distance computed for a single CQL command, plus the number of rows that were
fetched from the target table in order to compute it.
Represents a parsed Cassandra
duration literal, decomposed into its three
components: months, days, and nanoseconds.Parses a Cassandra duration string literal into a
CqlDurationLiteral.This class provides an empty implementation of
CqlParserVisitor,
which can be extended to create a visitor which only needs to handle a subset
of the available methods.Utility methods to parse CQL (Cassandra Query Language) commands with the ANTLR-generated
CqlParser, and to extract the information needed for heuristics computation (e.g.This interface defines a complete generic visitor for a parse tree produced
by
CqlParser.Represents a CQL query operation.
The keyspace/table a CQL SELECT, UPDATE, or DELETE statement targets, as extracted directly
from the parsed CQL AST.
contains a set of method to customize info for testing
need to check with Andrea if putting them in this interface or moving them to SutController
a customized criteria to check if a field is required or (not nullable) with the following
three situations
- only [annotationType] is specified, then the field with such annotation
would be considered as `required`
- [annotationType], [annotationMethod] and [equalsTo] are specified, then
the field is considered as `required` only if the field is applied with the annotation
and the method of the annotation returns the same value as [equalsTo]
cycle object
CypherParser implementation built on the official Neo4j Cypher25
ANTLR grammar.This class provides an empty implementation of
Cypher25ParserVisitor,
which can be extended to create a visitor which only needs to handle a subset
of the available methods.This interface defines a complete generic visitor for a parse tree produced
by
Cypher25Parser.Represents a condition extracted from a Cypher query.
Deep-clones a
CypherCondition (or Operand) while substituting the variable names it
refers to, according to a rename map.Visitor over the typed
CypherCondition boolean tree the parser produces.Parses the MATCH clause of a Cypher query into a structural
MatchOperation.Thrown when a Cypher query cannot be parsed: either it is not syntactically
valid Cypher, or it does not contain the expected MATCH clause.
Builds the default
CypherParser implementation.Represents a parsed Cypher query operation.
handle date param with java.util.Date
type schema for date
Parser for DynamoDB
DeleteItem requests.double param
util class for handling dto
Parser for one DynamoDB API method family.
DynamoDB attribute types accepted by the
attribute_type expression function.Normalizes DynamoDB request and response values into plain Java objects used by the expression
parser and heuristic calculator.
Executes DynamoDB insertions without binding the controller API to an AWS SDK version.
Associates an intercepted DynamoDB command and table with its heuristic result.
Shared normalized comparison type used by DynamoDB parsers and heuristics.
This class provides an empty implementation of
DynamoDbConditionExpressionVisitor,
which can be extended to create a visitor which only needs to handle a subset
of the available methods.This interface defines a complete generic visitor for a parse tree produced
by
DynamoDbConditionExpressionParser.Result of evaluating one DynamoDB predicate against the items of one table.
DSL for DynamoDB insertions in generated tests.
Parser for DynamoDB key/filter/condition expression strings.
Processes DynamoDB commands captured from the SUT and computes database heuristics for them.
Computes DynamoDB predicate heuristics directly as
Truthness values.Shared reflection helpers used by DynamoDB parser utilities.
Builds internal operations from DynamoDB request objects.
Entry point for a DynamoDB insertion sequence.
Fluent definition of one DynamoDB item.
Result of resolving a DynamoDB document path against a normalized item.
Represent $elemMatch operation.
{ field: { $elemMatch: { query1, query2, ... } } }
Main class used to implement an EvoMaster Driver.
Note: usually a RESTful webservice would be stateless.
endpoint dto for RPC service
enum parameter
enumeration
Represents a CQL equality comparison operation (
column = value).Equality comparison operation (
=).Represent $eq operation.
{ field: { $eq: value } }
DynamoDB existence predicate operation for
attribute_exists and
attribute_not_exists.Represent $exists operation.
{ field: { $exists: boolean } }
DSL (Domain Specific Language) for expectation management.
float param
Parser for DynamoDB
GetItem requests.Represents a CQL greater-than-or-equals comparison operation (
column >= value).Greater-than-or-equals comparison operation (
>=).Represent $gte operation.
{ field: { $gte: value } }
Represents a CQL greater-than comparison operation (
column > value).Greater-than comparison operation (
>).Represent $gt operation.
{ field: { $gt: value } }
Two possible implicit operations (no operator)
Equals: { field: value }
And: {{ expression1 }, { expression2 } , ... , { expressionN } }
Represents a CQL IN operation for a single column.
DynamoDB
path IN (...) predicate operation.Represent $in operation.
{ field: { $in: [value1, value2, ... valueN ] } }
Class responsible to handle the SutController in a way
in which bytecode instrumentation is activated.
schema dto of the RCP service
int param
supported specification of Java Dto
the specification would relate to how to construct dto
this class is to handle constraints defined with javax.validation.constraints
following the link
https://javaee.github.io/javaee-spec/javadocs/javax/validation/constraints/package-summary.html
Represent $jsonSchema operation.
Represents a label condition: n:Label
Extracted from patterns like (n:Person) or (n:Person:Employee)
Represents a CQL less-than-or-equals comparison operation (
column <= value).Less-than-or-equals comparison operation (
<=).Represent $lte operation.
{ field: { $lte: value } }
Represents a CQL less-than comparison operation (
column < value).Less-than comparison operation (
<).Represent $lt operation.
{ field: { $lt: value } }
A list operand, e.g. the right-hand side of x IN [1, 2, 3].
thrift
ArrayList (see https://thrift.apache.org/docs/types#containers)
A constant operand: a string, number, boolean or null literal.
long param
thrift
HashMap (see https://thrift.apache.org/docs/types#containers)
map type
Represents a parsed MATCH query containing the structural pattern and extracted conditions.
Represents the structural MATCH pattern (P_s) after stripping labels and properties.
Represent $mod operation.
{ field: { $mod: [ divisor, remainder ] } }
DSL (Domain Specific Language) for operations on
the Mongo Database
Class used to act upon Mongo commands executed by the SUT
Class used to execute Mongo commands
Selectors for operations whose value consist of a list of conditions
a named instance of the type with its value, eg Param/Field
it could be a request param or a response
Represent $near operation.
Parses
$near queries using either legacy coordinate pairs or GeoJSON points.Represent $nearSphere operation.
{ field: { $nearSphere: [ x, y ], $maxDistance: value, $minDistance: value } }
or
{ field: { $nearSphere: {$geometry: {type: "Point", coordinates: [ longitude, latitude ]}, $maxDistance: value, $minDistance: value}}
Pairs a captured Cypher query with its computed distance to being satisfied by the live graph.
Evaluates the truthness
ρ(condition, m) of a single CypherCondition under a
structural mapping m, recursively over the typed boolean tree the parser produces
(And/Or/Xor/Not, comparisons, label/type/property leaves).Result of scoring one captured Cypher query against the live graph: the distance to satisfying the
query, how many graph nodes were considered, and whether the evaluation failed.
An edge (relationship) of a captured Neo4j graph: a stable id, a single type, the ids of its two
endpoint nodes (source and target), and its property map.
An in-memory snapshot of a Neo4j graph (
G): the set of nodes and relationships against
which a parsed query is scored.Reads the live Neo4j graph into an in-memory
Neo4jGraph snapshot, used as G when
scoring Cypher queries.Acts upon Cypher queries executed by the SUT (captured as
Neo4JRunCommands): for each
captured query it computes how close the live graph is to satisfying it, as a distance to minimize.Computes the search heuristic
H(Q, G) of a parsed Cypher MATCH query Q against a
captured graph G, returning a Truthness (how close G is to satisfying
Q).A single structural mapping
m = (μ, ε) from a query pattern P_s onto a graph
G: it binds each pattern node variable to a graph node (μ) and each pattern edge
variable to a graph relationship (ε).A node of a captured Neo4j graph, used as the
G side when computing the heuristic
H(Q, G).Flattens a
MatchPattern into one with no variable-length relationships and no quantified
path patterns (QPPs), so the rest of the calculator only ever deals with plain nodes and edges.Enumerates
matched_elements(P_s, G): every structurally valid mapping (μ, ε) of a
stripped pattern onto a graph.Represent $nor operation.
{ $nor: [ { expression1 }, { expression2 },
Represents a logical NOT of a condition.
Inequality comparison operation (
<>).Represent $ne operation.
{ field: { $ne: value } }
Represent $nin operation.
{ field: { $nin: [ value1, value2 ... valueN ] } }
Logical NOT operation over one DynamoDB query condition.
Represent $not operation.
{ field: { $not: { operator-expression } } }
object param
object type
Helper class for working with OpenSearch queries.
One operand of a condition: a side of a WHERE comparison or an inline property value.
Represents a logical OR of multiple conditions.
Logical OR operation over multiple DynamoDB query conditions.
Represent $or operation.
{ $or: [ { expression1 }, { expression2 }, ... , { expressionN } ] }
map entry which is only used for handling map
used AbstractMap.SimpleEntry for handling map
A query parameter reference such as
$title, whose value is not written in the query but
supplied at execution time.Parsed DynamoDB request expressions for one table.
Represents an edge in a structural MATCH pattern.
Represents a node in a structural MATCH pattern (P_s).
Primitive types Param
primitive types
Depending on which kind of SUT we are dealing with (eg, REST, GraphQL or SPA frontend),
there is different info that must be provided.
Represents a property equality condition
n.key = value extracted from an inline property
map like {name: "Alice"}.A property reference operand: variable.key (e.g. n.age), resolved from the graph
element bound to the variable under the current mapping.
this is for handling bytes in gRPC with protobuf3 ByteString
handle it as string with utf8 now
copyFromUtf8
toStringUtf8
this class presents extracted info of a field of protobuf dto
Parser for DynamoDB
PutItem requests.A quantified path pattern (QPP), i.e. a sub-pattern repeated a number of times,
such as
((a)-[:KNOWS]->(b)){1,3}.Parser for DynamoDB
Query requests.Represents a DynamoDB condition/filter expression operation.
Represents a MongoDB query operation.
Represents an OpenSearch query operation.
Determines to which operation a query correspond.
A selector is used to determine if a query correspond to a certain operation.
A selector is used to determine if a query correspond to a certain operation.
A WHERE predicate kept unchanged because the structural model does not decompose
it (e.g. a boolean-returning function call or a bare boolean expression).
An operand kept unchanged because the model does not decompose it: a function call, a parameter,
or string concatenation.
This class will link a given RedisCommand to the result of the distance calculation for that commmand.
Class used to execute Redis commands
This class will have the distance for a RedisCommand (between 0 and 1)
and the number of evaluated keys in that distance calculation.
DSL (Domain Specific Language) for insertions on
the Redis Database.
Class used to act upon Redis commands executed by the SUT
This class will contain all necessary information from Redis to perform the distance calculation for a given command.
Utils class for auxiliary operations in Redis heuristic value calculations.
This class will hold the data associated to the value for a given key in Redis.
Talks to the SUT's Neo4j driver through reflection, so that EvoMaster never has a compile-time
dependency on
neo4j-java-driver and cannot clash with whichever version the SUT ships.RedisClient that uses Lettuce dynamically via reflection, avoiding
compile-time dependency on Spring or Lettuce.
Represent $regex operation.
Options supported by MongoDB's
$regex operator.Parses
{ field: { $regex: pattern, $options: options } } queries.Created by arcuri82 on 05-Nov-18.
created by manzhang on 2021/11/4
handle RPC exception, for instance
- extract possible category eg, application, protocol, if possible
- extract exception info, eg, customized exception, message, or status code
define RPCProblem used in driver
Parser for DynamoDB
Scan requests.thrift
HashSet (see https://thrift.apache.org/docs/types#containers)
int param
DynamoDB
size(path) comparator value predicate operation.Represent $size operation.
{ field: { $size: value } }
string param
string type
Abstract class used to connect to the EvoMaster process, and
that is responsible to start/stop/restart the tested application,
ie the system under test (SUT)
Base interface used to control the System Under Test (SUT)
from the generated tests.
Represent Term operation.
{ term: { field: value } }
Represent $text operation.
Represents the "{}" MongoDB query.
Represents a relationship type condition: type(r) = T
Extracted from patterns like -[:KNOWS]-> or -[r:WORKS_AT]->
DynamoDB
attribute_type(path, type) predicate operation.Represent $type operation.
type schema
{ field: { $type: BSON type } }
Parser for DynamoDB
UpdateItem requests.Represent $where operation.
Represents a logical XOR of multiple conditions.