spec/expressir/express_exp/syntax_spec.rb in expressir-0.2.0 vs spec/expressir/express_exp/syntax_spec.rb in expressir-0.2.1
- old
+ new
@@ -1,17 +1,18 @@
require "spec_helper"
-require_relative "../../../lib/expressir/express_exp/parser"
+require "expressir/express_exp/parser"
RSpec.describe Expressir::ExpressExp::Parser do
describe ".from_file" do
it "build an instance from a file" do
repo = Expressir::ExpressExp::Parser.from_exp(sample_file)
schemas = repo.schemas
schema = schemas.find{|x| x.id == "syntaxSchema"}
- expect(schema.version).to eq("version")
+ expect(schema.version).to be_instance_of(Expressir::Model::Literals::String)
+ expect(schema.version.value).to eq("version")
interfaces = schema.interfaces
constants = schema.constants
types = schema.types
entities = schema.entities
@@ -65,39 +66,48 @@
expect(x.items[0].id).to eq("test2")
end
# literals
constants.find{|x| x.id == "binaryExpression"}.expression.tap do |x|
- expect(x).to eq("xxx")
+ expect(x).to be_instance_of(Expressir::Model::Literals::Binary)
+ expect(x.value).to eq("011110000111100001111000")
end
constants.find{|x| x.id == "integerExpression"}.expression.tap do |x|
- expect(x).to eq(999)
+ expect(x).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.value).to eq("999")
end
- constants.find{|x| x.id == "logicalTrueExpression"}.expression.tap do |x|
- expect(x).to eq(true)
+ constants.find{|x| x.id == "trueLogicalExpression"}.expression.tap do |x|
+ expect(x).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.value).to eq(true)
end
- constants.find{|x| x.id == "logicalFalseExpression"}.expression.tap do |x|
- expect(x).to eq(false)
+ constants.find{|x| x.id == "falseLogicalExpression"}.expression.tap do |x|
+ expect(x).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.value).to eq(false)
end
- constants.find{|x| x.id == "logicalUnknownExpression"}.expression.tap do |x|
- expect(x).to be_instance_of(Expressir::Model::Expressions::Unknown)
+ constants.find{|x| x.id == "unknownLogicalExpression"}.expression.tap do |x|
+ expect(x).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.value).to eq(nil)
end
constants.find{|x| x.id == "realExpression"}.expression.tap do |x|
- expect(x).to eq(999.999)
+ expect(x).to be_instance_of(Expressir::Model::Literals::Real)
+ expect(x.value).to eq("999.999")
end
- constants.find{|x| x.id == "stringSimpleExpression"}.expression.tap do |x|
- expect(x).to eq("xxx")
+ constants.find{|x| x.id == "simpleStringExpression"}.expression.tap do |x|
+ expect(x).to be_instance_of(Expressir::Model::Literals::String)
+ expect(x.value).to eq("xxx")
end
- constants.find{|x| x.id == "stringEncodedExpression"}.expression.tap do |x|
- expect(x).to eq("xxx")
+ constants.find{|x| x.id == "encodedStringExpression"}.expression.tap do |x|
+ expect(x).to be_instance_of(Expressir::Model::Literals::String)
+ expect(x.value).to eq("000000780000007800000078")
+ expect(x.encoded).to eq(true)
end
# constants
constants.find{|x| x.id == "constEExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Ref)
@@ -124,343 +134,388 @@
expect(x).to be_instance_of(Expressir::Model::Expressions::FunctionCall)
expect(x.function).to be_instance_of(Expressir::Model::Ref)
expect(x.function.id).to eq("ABS")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
constants.find{|x| x.id == "acosExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::FunctionCall)
expect(x.function).to be_instance_of(Expressir::Model::Ref)
expect(x.function.id).to eq("ACOS")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
constants.find{|x| x.id == "asinExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::FunctionCall)
expect(x.function).to be_instance_of(Expressir::Model::Ref)
expect(x.function.id).to eq("ASIN")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
constants.find{|x| x.id == "atanExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::FunctionCall)
expect(x.function).to be_instance_of(Expressir::Model::Ref)
expect(x.function.id).to eq("ATAN")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
constants.find{|x| x.id == "blengthExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::FunctionCall)
expect(x.function).to be_instance_of(Expressir::Model::Ref)
expect(x.function.id).to eq("BLENGTH")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
constants.find{|x| x.id == "cosExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::FunctionCall)
expect(x.function).to be_instance_of(Expressir::Model::Ref)
expect(x.function.id).to eq("COS")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
constants.find{|x| x.id == "existsExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::FunctionCall)
expect(x.function).to be_instance_of(Expressir::Model::Ref)
expect(x.function.id).to eq("EXISTS")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
constants.find{|x| x.id == "expExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::FunctionCall)
expect(x.function).to be_instance_of(Expressir::Model::Ref)
expect(x.function.id).to eq("EXP")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
constants.find{|x| x.id == "formatExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::FunctionCall)
expect(x.function).to be_instance_of(Expressir::Model::Ref)
expect(x.function.id).to eq("FORMAT")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
constants.find{|x| x.id == "hiboundExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::FunctionCall)
expect(x.function).to be_instance_of(Expressir::Model::Ref)
expect(x.function.id).to eq("HIBOUND")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
constants.find{|x| x.id == "hiindexExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::FunctionCall)
expect(x.function).to be_instance_of(Expressir::Model::Ref)
expect(x.function.id).to eq("HIINDEX")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
constants.find{|x| x.id == "lengthExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::FunctionCall)
expect(x.function).to be_instance_of(Expressir::Model::Ref)
expect(x.function.id).to eq("LENGTH")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
constants.find{|x| x.id == "loboundExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::FunctionCall)
expect(x.function).to be_instance_of(Expressir::Model::Ref)
expect(x.function.id).to eq("LOBOUND")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
constants.find{|x| x.id == "loindexExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::FunctionCall)
expect(x.function).to be_instance_of(Expressir::Model::Ref)
expect(x.function.id).to eq("LOINDEX")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
constants.find{|x| x.id == "logExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::FunctionCall)
expect(x.function).to be_instance_of(Expressir::Model::Ref)
expect(x.function.id).to eq("LOG")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
constants.find{|x| x.id == "log2Expression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::FunctionCall)
expect(x.function).to be_instance_of(Expressir::Model::Ref)
expect(x.function.id).to eq("LOG2")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
constants.find{|x| x.id == "log10Expression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::FunctionCall)
expect(x.function).to be_instance_of(Expressir::Model::Ref)
expect(x.function.id).to eq("LOG10")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
constants.find{|x| x.id == "nvlExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::FunctionCall)
expect(x.function).to be_instance_of(Expressir::Model::Ref)
expect(x.function.id).to eq("NVL")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
constants.find{|x| x.id == "oddExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::FunctionCall)
expect(x.function).to be_instance_of(Expressir::Model::Ref)
expect(x.function.id).to eq("ODD")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
constants.find{|x| x.id == "rolesofExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::FunctionCall)
expect(x.function).to be_instance_of(Expressir::Model::Ref)
expect(x.function.id).to eq("ROLESOF")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
constants.find{|x| x.id == "sinExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::FunctionCall)
expect(x.function).to be_instance_of(Expressir::Model::Ref)
expect(x.function.id).to eq("SIN")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
constants.find{|x| x.id == "sizeofExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::FunctionCall)
expect(x.function).to be_instance_of(Expressir::Model::Ref)
expect(x.function.id).to eq("SIZEOF")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
constants.find{|x| x.id == "sqrtExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::FunctionCall)
expect(x.function).to be_instance_of(Expressir::Model::Ref)
expect(x.function.id).to eq("SQRT")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
constants.find{|x| x.id == "tanExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::FunctionCall)
expect(x.function).to be_instance_of(Expressir::Model::Ref)
expect(x.function.id).to eq("TAN")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
constants.find{|x| x.id == "typeofExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::FunctionCall)
expect(x.function).to be_instance_of(Expressir::Model::Ref)
expect(x.function.id).to eq("TYPEOF")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
constants.find{|x| x.id == "usedinExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::FunctionCall)
expect(x.function).to be_instance_of(Expressir::Model::Ref)
expect(x.function.id).to eq("USEDIN")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
constants.find{|x| x.id == "valueExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::FunctionCall)
expect(x.function).to be_instance_of(Expressir::Model::Ref)
expect(x.function.id).to eq("VALUE")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
constants.find{|x| x.id == "valueInExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::FunctionCall)
expect(x.function).to be_instance_of(Expressir::Model::Ref)
expect(x.function.id).to eq("VALUE_IN")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
constants.find{|x| x.id == "valueUniqueExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::FunctionCall)
expect(x.function).to be_instance_of(Expressir::Model::Ref)
expect(x.function.id).to eq("VALUE_UNIQUE")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
# operations
constants.find{|x| x.id == "unaryPlusExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::UnaryPlus)
expect(x.operands).to be_instance_of(Array)
expect(x.operands.count).to eq(1)
- expect(x.operands[0]).to eq(4)
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[0].value).to eq("4")
end
constants.find{|x| x.id == "unaryMinusExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::UnaryMinus)
expect(x.operands).to be_instance_of(Array)
expect(x.operands.count).to eq(1)
- expect(x.operands[0]).to eq(4)
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[0].value).to eq("4")
end
constants.find{|x| x.id == "additionExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::Addition)
expect(x.operands).to be_instance_of(Array)
expect(x.operands.count).to eq(2)
- expect(x.operands[0]).to eq(4)
- expect(x.operands[1]).to eq(2)
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[0].value).to eq("4")
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[1].value).to eq("2")
end
constants.find{|x| x.id == "subtractionExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::Subtraction)
expect(x.operands).to be_instance_of(Array)
expect(x.operands.count).to eq(2)
- expect(x.operands[0]).to eq(4)
- expect(x.operands[1]).to eq(2)
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[0].value).to eq("4")
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[1].value).to eq("2")
end
constants.find{|x| x.id == "multiplicationExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::Multiplication)
expect(x.operands).to be_instance_of(Array)
expect(x.operands.count).to eq(2)
- expect(x.operands[0]).to eq(4)
- expect(x.operands[1]).to eq(2)
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[0].value).to eq("4")
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[1].value).to eq("2")
end
constants.find{|x| x.id == "realDivisionExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::RealDivision)
expect(x.operands).to be_instance_of(Array)
expect(x.operands.count).to eq(2)
- expect(x.operands[0]).to eq(4)
- expect(x.operands[1]).to eq(2)
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[0].value).to eq("4")
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[1].value).to eq("2")
end
constants.find{|x| x.id == "integerDivisionExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::IntegerDivision)
expect(x.operands).to be_instance_of(Array)
expect(x.operands.count).to eq(2)
- expect(x.operands[0]).to eq(4)
- expect(x.operands[1]).to eq(2)
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[0].value).to eq("4")
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[1].value).to eq("2")
end
constants.find{|x| x.id == "moduloExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::Modulo)
expect(x.operands).to be_instance_of(Array)
expect(x.operands.count).to eq(2)
- expect(x.operands[0]).to eq(4)
- expect(x.operands[1]).to eq(2)
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[0].value).to eq("4")
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[1].value).to eq("2")
end
constants.find{|x| x.id == "exponentiationExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::Exponentiation)
expect(x.operands).to be_instance_of(Array)
expect(x.operands.count).to eq(2)
- expect(x.operands[0]).to eq(4)
- expect(x.operands[1]).to eq(2)
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[0].value).to eq("4")
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[1].value).to eq("2")
end
constants.find{|x| x.id == "additionAdditionExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::Addition)
@@ -468,13 +523,16 @@
expect(x.operands.count).to eq(2)
expect(x.operands[0]).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operands[0].operator).to be_instance_of(Expressir::Model::Operators::Addition)
expect(x.operands[0].operands).to be_instance_of(Array)
expect(x.operands[0].operands.count).to eq(2)
- expect(x.operands[0].operands[0]).to eq(4)
- expect(x.operands[0].operands[1]).to eq(2)
- expect(x.operands[1]).to eq(1)
+ expect(x.operands[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[0].operands[0].value).to eq("4")
+ expect(x.operands[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[0].operands[1].value).to eq("2")
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[1].value).to eq("1")
end
constants.find{|x| x.id == "subtractionSubtractionExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::Subtraction)
@@ -482,13 +540,16 @@
expect(x.operands.count).to eq(2)
expect(x.operands[0]).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operands[0].operator).to be_instance_of(Expressir::Model::Operators::Subtraction)
expect(x.operands[0].operands).to be_instance_of(Array)
expect(x.operands[0].operands.count).to eq(2)
- expect(x.operands[0].operands[0]).to eq(4)
- expect(x.operands[0].operands[1]).to eq(2)
- expect(x.operands[1]).to eq(1)
+ expect(x.operands[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[0].operands[0].value).to eq("4")
+ expect(x.operands[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[0].operands[1].value).to eq("2")
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[1].value).to eq("1")
end
constants.find{|x| x.id == "additionSubtractionExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::Subtraction)
@@ -496,13 +557,16 @@
expect(x.operands.count).to eq(2)
expect(x.operands[0]).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operands[0].operator).to be_instance_of(Expressir::Model::Operators::Addition)
expect(x.operands[0].operands).to be_instance_of(Array)
expect(x.operands[0].operands.count).to eq(2)
- expect(x.operands[0].operands[0]).to eq(4)
- expect(x.operands[0].operands[1]).to eq(2)
- expect(x.operands[1]).to eq(1)
+ expect(x.operands[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[0].operands[0].value).to eq("4")
+ expect(x.operands[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[0].operands[1].value).to eq("2")
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[1].value).to eq("1")
end
constants.find{|x| x.id == "subtractionAdditionExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::Addition)
@@ -510,27 +574,33 @@
expect(x.operands.count).to eq(2)
expect(x.operands[0]).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operands[0].operator).to be_instance_of(Expressir::Model::Operators::Subtraction)
expect(x.operands[0].operands).to be_instance_of(Array)
expect(x.operands[0].operands.count).to eq(2)
- expect(x.operands[0].operands[0]).to eq(4)
- expect(x.operands[0].operands[1]).to eq(2)
- expect(x.operands[1]).to eq(1)
+ expect(x.operands[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[0].operands[0].value).to eq("4")
+ expect(x.operands[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[0].operands[1].value).to eq("2")
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[1].value).to eq("1")
end
constants.find{|x| x.id == "additionMultiplicationExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::Addition)
expect(x.operands).to be_instance_of(Array)
expect(x.operands.count).to eq(2)
- expect(x.operands[0]).to eq(8)
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[0].value).to eq("8")
expect(x.operands[1]).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operands[1].operator).to be_instance_of(Expressir::Model::Operators::Multiplication)
expect(x.operands[1].operands).to be_instance_of(Array)
expect(x.operands[1].operands.count).to eq(2)
- expect(x.operands[1].operands[0]).to eq(4)
- expect(x.operands[1].operands[1]).to eq(2)
+ expect(x.operands[1].operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[1].operands[0].value).to eq("4")
+ expect(x.operands[1].operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[1].operands[1].value).to eq("2")
end
constants.find{|x| x.id == "multiplicationAdditionExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::Addition)
@@ -538,13 +608,16 @@
expect(x.operands.count).to eq(2)
expect(x.operands[0]).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operands[0].operator).to be_instance_of(Expressir::Model::Operators::Multiplication)
expect(x.operands[0].operands).to be_instance_of(Array)
expect(x.operands[0].operands.count).to eq(2)
- expect(x.operands[0].operands[0]).to eq(8)
- expect(x.operands[0].operands[1]).to eq(4)
- expect(x.operands[1]).to eq(2)
+ expect(x.operands[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[0].operands[0].value).to eq("8")
+ expect(x.operands[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[0].operands[1].value).to eq("4")
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[1].value).to eq("2")
end
constants.find{|x| x.id == "parenthesisAdditionMultiplicationExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::Multiplication)
@@ -552,111 +625,138 @@
expect(x.operands.count).to eq(2)
expect(x.operands[0]).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operands[0].operator).to be_instance_of(Expressir::Model::Operators::Addition)
expect(x.operands[0].operands).to be_instance_of(Array)
expect(x.operands[0].operands.count).to eq(2)
- expect(x.operands[0].operands[0]).to eq(8)
- expect(x.operands[0].operands[1]).to eq(4)
- expect(x.operands[1]).to eq(2)
+ expect(x.operands[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[0].operands[0].value).to eq("8")
+ expect(x.operands[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[0].operands[1].value).to eq("4")
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[1].value).to eq("2")
end
constants.find{|x| x.id == "multiplicationParenthesisAdditionExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::Multiplication)
expect(x.operands).to be_instance_of(Array)
expect(x.operands.count).to eq(2)
- expect(x.operands[0]).to eq(8)
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[0].value).to eq("8")
expect(x.operands[1]).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operands[1].operator).to be_instance_of(Expressir::Model::Operators::Addition)
expect(x.operands[1].operands).to be_instance_of(Array)
expect(x.operands[1].operands.count).to eq(2)
- expect(x.operands[1].operands[0]).to eq(4)
- expect(x.operands[1].operands[1]).to eq(2)
+ expect(x.operands[1].operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[1].operands[0].value).to eq("4")
+ expect(x.operands[1].operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[1].operands[1].value).to eq("2")
end
constants.find{|x| x.id == "equalExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::Equal)
expect(x.operands).to be_instance_of(Array)
expect(x.operands.count).to eq(2)
- expect(x.operands[0]).to eq(4)
- expect(x.operands[1]).to eq(2)
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[0].value).to eq("4")
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[1].value).to eq("2")
end
constants.find{|x| x.id == "notEqualExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::NotEqual)
expect(x.operands).to be_instance_of(Array)
expect(x.operands.count).to eq(2)
- expect(x.operands[0]).to eq(4)
- expect(x.operands[1]).to eq(2)
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[0].value).to eq("4")
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[1].value).to eq("2")
end
constants.find{|x| x.id == "ltExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::LessThan)
expect(x.operands).to be_instance_of(Array)
expect(x.operands.count).to eq(2)
- expect(x.operands[0]).to eq(4)
- expect(x.operands[1]).to eq(2)
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[0].value).to eq("4")
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[1].value).to eq("2")
end
constants.find{|x| x.id == "gtExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::GreaterThan)
expect(x.operands).to be_instance_of(Array)
expect(x.operands.count).to eq(2)
- expect(x.operands[0]).to eq(4)
- expect(x.operands[1]).to eq(2)
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[0].value).to eq("4")
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[1].value).to eq("2")
end
constants.find{|x| x.id == "lteExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::LessThanOrEqual)
expect(x.operands).to be_instance_of(Array)
expect(x.operands.count).to eq(2)
- expect(x.operands[0]).to eq(4)
- expect(x.operands[1]).to eq(2)
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[0].value).to eq("4")
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[1].value).to eq("2")
end
constants.find{|x| x.id == "gteExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::GreaterThanOrEqual)
expect(x.operands).to be_instance_of(Array)
expect(x.operands.count).to eq(2)
- expect(x.operands[0]).to eq(4)
- expect(x.operands[1]).to eq(2)
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[0].value).to eq("4")
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.operands[1].value).to eq("2")
end
constants.find{|x| x.id == "orExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::Or)
expect(x.operands).to be_instance_of(Array)
expect(x.operands.count).to eq(2)
- expect(x.operands[0]).to eq(true)
- expect(x.operands[1]).to eq(false)
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.operands[0].value).to eq(true)
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.operands[1].value).to eq(false)
end
constants.find{|x| x.id == "andExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::And)
expect(x.operands).to be_instance_of(Array)
expect(x.operands.count).to eq(2)
- expect(x.operands[0]).to eq(true)
- expect(x.operands[1]).to eq(false)
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.operands[0].value).to eq(true)
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.operands[1].value).to eq(false)
end
constants.find{|x| x.id == "orOrExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::Or)
+ expect(x.operands).to be_instance_of(Array)
+ expect(x.operands.count).to eq(2)
expect(x.operands[0]).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operands[0].operator).to be_instance_of(Expressir::Model::Operators::Or)
expect(x.operands[0].operands).to be_instance_of(Array)
expect(x.operands[0].operands.count).to eq(2)
- expect(x.operands[0].operands[0]).to eq(true)
- expect(x.operands[0].operands[1]).to eq(false)
- expect(x.operands[1]).to eq(true)
+ expect(x.operands[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.operands[0].operands[0].value).to eq(true)
+ expect(x.operands[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.operands[0].operands[1].value).to eq(false)
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.operands[1].value).to eq(true)
end
constants.find{|x| x.id == "andAndExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::And)
@@ -664,27 +764,33 @@
expect(x.operands.count).to eq(2)
expect(x.operands[0]).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operands[0].operator).to be_instance_of(Expressir::Model::Operators::And)
expect(x.operands[0].operands).to be_instance_of(Array)
expect(x.operands[0].operands.count).to eq(2)
- expect(x.operands[0].operands[0]).to eq(true)
- expect(x.operands[0].operands[1]).to eq(false)
- expect(x.operands[1]).to eq(true)
+ expect(x.operands[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.operands[0].operands[0].value).to eq(true)
+ expect(x.operands[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.operands[0].operands[1].value).to eq(false)
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.operands[1].value).to eq(true)
end
constants.find{|x| x.id == "orAndExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::Or)
expect(x.operands).to be_instance_of(Array)
expect(x.operands.count).to eq(2)
- expect(x.operands[0]).to eq(true)
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.operands[0].value).to eq(true)
expect(x.operands[1]).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operands[1].operator).to be_instance_of(Expressir::Model::Operators::And)
expect(x.operands[1].operands).to be_instance_of(Array)
expect(x.operands[1].operands.count).to eq(2)
- expect(x.operands[1].operands[0]).to eq(false)
- expect(x.operands[1].operands[1]).to eq(true)
+ expect(x.operands[1].operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.operands[1].operands[0].value).to eq(false)
+ expect(x.operands[1].operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.operands[1].operands[1].value).to eq(true)
end
constants.find{|x| x.id == "andOrExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::Or)
@@ -692,13 +798,16 @@
expect(x.operands.count).to eq(2)
expect(x.operands[0]).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operands[0].operator).to be_instance_of(Expressir::Model::Operators::And)
expect(x.operands[0].operands).to be_instance_of(Array)
expect(x.operands[0].operands.count).to eq(2)
- expect(x.operands[0].operands[0]).to eq(true)
- expect(x.operands[0].operands[1]).to eq(false)
- expect(x.operands[1]).to eq(true)
+ expect(x.operands[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.operands[0].operands[0].value).to eq(true)
+ expect(x.operands[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.operands[0].operands[1].value).to eq(false)
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.operands[1].value).to eq(true)
end
constants.find{|x| x.id == "parenthesisOrAndExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::And)
@@ -706,81 +815,101 @@
expect(x.operands.count).to eq(2)
expect(x.operands[0]).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operands[0].operator).to be_instance_of(Expressir::Model::Operators::Or)
expect(x.operands[0].operands).to be_instance_of(Array)
expect(x.operands[0].operands.count).to eq(2)
- expect(x.operands[0].operands[0]).to eq(true)
- expect(x.operands[0].operands[1]).to eq(false)
- expect(x.operands[1]).to eq(true)
+ expect(x.operands[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.operands[0].operands[0].value).to eq(true)
+ expect(x.operands[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.operands[0].operands[1].value).to eq(false)
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.operands[1].value).to eq(true)
end
constants.find{|x| x.id == "andParenthesisOrExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::And)
expect(x.operands).to be_instance_of(Array)
expect(x.operands.count).to eq(2)
- expect(x.operands[0]).to eq(true)
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.operands[0].value).to eq(true)
expect(x.operands[1]).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operands[1].operator).to be_instance_of(Expressir::Model::Operators::Or)
expect(x.operands[1].operands).to be_instance_of(Array)
expect(x.operands[1].operands.count).to eq(2)
- expect(x.operands[1].operands[0]).to eq(false)
- expect(x.operands[1].operands[1]).to eq(true)
+ expect(x.operands[1].operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.operands[1].operands[0].value).to eq(false)
+ expect(x.operands[1].operands[1]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.operands[1].operands[1].value).to eq(true)
end
# aggregate initializers
- constants.find{|x| x.id == "aggregateExpression"}.expression.tap do |x|
- expect(x).to be_instance_of(Array)
- expect(x.count).to eq(1)
- expect(x[0]).to eq("xxx")
+ constants.find{|x| x.id == "aggregateInitializerExpression"}.expression.tap do |x|
+ expect(x).to be_instance_of(Expressir::Model::Expressions::AggregateInitializer)
+ expect(x.items).to be_instance_of(Array)
+ expect(x.items.count).to eq(1)
+ expect(x.items[0]).to be_instance_of(Expressir::Model::Literals::String)
+ expect(x.items[0].value).to eq("xxx")
end
- constants.find{|x| x.id == "aggregateRepeatedExpression"}.expression.tap do |x|
- expect(x).to be_instance_of(Array)
- expect(x.count).to eq(1)
- expect(x[0]).to be_instance_of(Expressir::Model::Expressions::AggregateElement)
- expect(x[0].expression).to eq("xxx")
- expect(x[0].repetition).to eq(2)
+ constants.find{|x| x.id == "repeatedAggregateInitializerExpression"}.expression.tap do |x|
+ expect(x).to be_instance_of(Expressir::Model::Expressions::AggregateInitializer)
+ expect(x.items).to be_instance_of(Array)
+ expect(x.items.count).to eq(1)
+ expect(x.items[0]).to be_instance_of(Expressir::Model::Expressions::AggregateElement)
+ expect(x.items[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+ expect(x.items[0].expression.value).to eq("xxx")
+ expect(x.items[0].repetition).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.items[0].repetition.value).to eq("2")
end
- constants.find{|x| x.id == "aggregateComplexExpression"}.expression.tap do |x|
- expect(x).to be_instance_of(Array)
- expect(x.count).to eq(1)
- expect(x[0]).to be_instance_of(Expressir::Model::Expressions::Expression)
- expect(x[0].operator).to be_instance_of(Expressir::Model::Operators::Addition)
- expect(x[0].operands).to be_instance_of(Array)
- expect(x[0].operands.count).to eq(2)
- expect(x[0].operands[0]).to eq(4)
- expect(x[0].operands[1]).to eq(2)
+ constants.find{|x| x.id == "complexAggregateInitializerExpression"}.expression.tap do |x|
+ expect(x).to be_instance_of(Expressir::Model::Expressions::AggregateInitializer)
+ expect(x.items).to be_instance_of(Array)
+ expect(x.items.count).to eq(1)
+ expect(x.items[0]).to be_instance_of(Expressir::Model::Expressions::Expression)
+ expect(x.items[0].operator).to be_instance_of(Expressir::Model::Operators::Addition)
+ expect(x.items[0].operands).to be_instance_of(Array)
+ expect(x.items[0].operands.count).to eq(2)
+ expect(x.items[0].operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.items[0].operands[0].value).to eq("4")
+ expect(x.items[0].operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.items[0].operands[1].value).to eq("2")
end
- constants.find{|x| x.id == "aggregateComplexRepeatedExpression"}.expression.tap do |x|
- expect(x).to be_instance_of(Array)
- expect(x.count).to eq(1)
- expect(x[0]).to be_instance_of(Expressir::Model::Expressions::AggregateElement)
- expect(x[0].expression).to be_instance_of(Expressir::Model::Expressions::Expression)
- expect(x[0].expression.operator).to be_instance_of(Expressir::Model::Operators::Addition)
- expect(x[0].expression.operands).to be_instance_of(Array)
- expect(x[0].expression.operands.count).to eq(2)
- expect(x[0].expression.operands[0]).to eq(4)
- expect(x[0].expression.operands[1]).to eq(2)
- expect(x[0].repetition).to be_instance_of(Expressir::Model::Expressions::Expression)
- expect(x[0].repetition.operator).to be_instance_of(Expressir::Model::Operators::Addition)
- expect(x[0].repetition.operands).to be_instance_of(Array)
- expect(x[0].repetition.operands.count).to eq(2)
- expect(x[0].repetition.operands[0]).to eq(4)
- expect(x[0].repetition.operands[1]).to eq(2)
+ constants.find{|x| x.id == "complexRepeatedAggregateInitializerExpression"}.expression.tap do |x|
+ expect(x).to be_instance_of(Expressir::Model::Expressions::AggregateInitializer)
+ expect(x.items).to be_instance_of(Array)
+ expect(x.items.count).to eq(1)
+ expect(x.items[0]).to be_instance_of(Expressir::Model::Expressions::AggregateElement)
+ expect(x.items[0].expression).to be_instance_of(Expressir::Model::Expressions::Expression)
+ expect(x.items[0].expression.operator).to be_instance_of(Expressir::Model::Operators::Addition)
+ expect(x.items[0].expression.operands).to be_instance_of(Array)
+ expect(x.items[0].expression.operands.count).to eq(2)
+ expect(x.items[0].expression.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.items[0].expression.operands[0].value).to eq("4")
+ expect(x.items[0].expression.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.items[0].expression.operands[1].value).to eq("2")
+ expect(x.items[0].repetition).to be_instance_of(Expressir::Model::Expressions::Expression)
+ expect(x.items[0].repetition.operator).to be_instance_of(Expressir::Model::Operators::Addition)
+ expect(x.items[0].repetition.operands).to be_instance_of(Array)
+ expect(x.items[0].repetition.operands.count).to eq(2)
+ expect(x.items[0].repetition.operands[0]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.items[0].repetition.operands[0].value).to eq("4")
+ expect(x.items[0].repetition.operands[1]).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.items[0].repetition.operands[1].value).to eq("2")
end
# entity constructors
constants.find{|x| x.id == "entityConstructorExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::EntityConstructor)
expect(x.entity).to be_instance_of(Expressir::Model::Ref)
expect(x.entity.id).to eq("explicitAttributeEntity")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
# enumeration references
constants.find{|x| x.id == "enumerationReferenceExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Ref)
@@ -799,42 +928,54 @@
end
# intervals
constants.find{|x| x.id == "ltLtIntervalExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Interval)
- expect(x.low).to eq(1)
+ expect(x.low).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.low.value).to eq("1")
expect(x.operator1).to be_instance_of(Expressir::Model::Operators::LessThan)
- expect(x.item).to eq(5)
+ expect(x.item).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.item.value).to eq("5")
expect(x.operator2).to be_instance_of(Expressir::Model::Operators::LessThan)
- expect(x.high).to eq(9)
+ expect(x.high).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.high.value).to eq("9")
end
constants.find{|x| x.id == "lteLtIntervalExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Interval)
- expect(x.low).to eq(1)
+ expect(x.low).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.low.value).to eq("1")
expect(x.operator1).to be_instance_of(Expressir::Model::Operators::LessThanOrEqual)
- expect(x.item).to eq(5)
+ expect(x.item).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.item.value).to eq("5")
expect(x.operator2).to be_instance_of(Expressir::Model::Operators::LessThan)
- expect(x.high).to eq(9)
+ expect(x.high).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.high.value).to eq("9")
end
constants.find{|x| x.id == "ltLteIntervalExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Interval)
- expect(x.low).to eq(1)
+ expect(x.low).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.low.value).to eq("1")
expect(x.operator1).to be_instance_of(Expressir::Model::Operators::LessThan)
- expect(x.item).to eq(5)
+ expect(x.item).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.item.value).to eq("5")
expect(x.operator2).to be_instance_of(Expressir::Model::Operators::LessThanOrEqual)
- expect(x.high).to eq(9)
+ expect(x.high).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.high.value).to eq("9")
end
constants.find{|x| x.id == "lteLteIntervalExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Interval)
- expect(x.low).to eq(1)
+ expect(x.low).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.low.value).to eq("1")
expect(x.operator1).to be_instance_of(Expressir::Model::Operators::LessThanOrEqual)
- expect(x.item).to eq(5)
+ expect(x.item).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.item.value).to eq("5")
expect(x.operator2).to be_instance_of(Expressir::Model::Operators::LessThanOrEqual)
- expect(x.high).to eq(9)
+ expect(x.high).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.high.value).to eq("9")
end
constants.find{|x| x.id == "combineExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::Combine)
@@ -849,32 +990,38 @@
constants.find{|x| x.id == "inExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::In)
expect(x.operands).to be_instance_of(Array)
expect(x.operands.count).to eq(2)
- expect(x.operands[0]).to eq(true)
- expect(x.operands[1]).to be_instance_of(Array)
- expect(x.operands[1].count).to eq(1)
- expect(x.operands[1][0]).to eq(true)
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.operands[0].value).to eq(true)
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Expressions::AggregateInitializer)
+ expect(x.operands[1].items).to be_instance_of(Array)
+ expect(x.operands[1].items.count).to eq(1)
+ expect(x.operands[1].items[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.operands[1].items[0].value).to eq(true)
end
constants.find{|x| x.id == "likeExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Expression)
expect(x.operator).to be_instance_of(Expressir::Model::Operators::Like)
expect(x.operands).to be_instance_of(Array)
expect(x.operands.count).to eq(2)
- expect(x.operands[0]).to eq("xxx")
- expect(x.operands[1]).to eq("xxx")
+ expect(x.operands[0]).to be_instance_of(Expressir::Model::Literals::String)
+ expect(x.operands[0].value).to eq("xxx")
+ expect(x.operands[1]).to be_instance_of(Expressir::Model::Literals::String)
+ expect(x.operands[1].value).to eq("xxx")
end
# queries
constants.find{|x| x.id == "queryExpression"}.expression.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Expressions::Query)
expect(x.id).to eq("test")
expect(x.source).to be_instance_of(Expressir::Model::Ref)
expect(x.source.id).to eq("test2")
- expect(x.expression).to eq(true)
+ expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.expression.value).to eq(true)
end
# types
types.find{|x| x.id == "integerType"}.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Type)
@@ -885,36 +1032,40 @@
expect(x).to be_instance_of(Expressir::Model::Type)
expect(x.type).to be_instance_of(Expressir::Model::Types::Integer)
expect(x.where).to be_instance_of(Array)
expect(x.where.count).to eq(1)
expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
- expect(x.where[0].expression).to eq(true)
+ expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.where[0].expression.value).to eq(true)
end
types.find{|x| x.id == "integerWhereLabelType"}.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Type)
expect(x.type).to be_instance_of(Expressir::Model::Types::Integer)
expect(x.where).to be_instance_of(Array)
expect(x.where.count).to eq(1)
expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
expect(x.where[0].id).to eq("WR1")
- expect(x.where[0].expression).to eq(true)
+ expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.where[0].expression.value).to eq(true)
end
# simple types
types.find{|x| x.id == "binaryType"}.type.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Types::Binary)
end
types.find{|x| x.id == "binaryWidthType"}.type.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Types::Binary)
- expect(x.width).to eq(3)
+ expect(x.width).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.width.value).to eq("3")
end
types.find{|x| x.id == "binaryWidthFixedType"}.type.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Types::Binary)
- expect(x.width).to eq(3)
+ expect(x.width).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.width.value).to eq("3")
expect(x.fixed).to eq(true)
end
types.find{|x| x.id == "booleanType"}.type.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Types::Boolean)
@@ -936,56 +1087,67 @@
expect(x).to be_instance_of(Expressir::Model::Types::Real)
end
types.find{|x| x.id == "realPrecisionType"}.type.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Types::Real)
- expect(x.precision).to eq(3)
+ expect(x.precision).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.precision.value).to eq("3")
end
types.find{|x| x.id == "stringType"}.type.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Types::String)
end
types.find{|x| x.id == "stringWidthType"}.type.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Types::String)
- expect(x.width).to eq(3)
+ expect(x.width).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.width.value).to eq("3")
end
types.find{|x| x.id == "stringWidthFixedType"}.type.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Types::String)
- expect(x.width).to eq(3)
+ expect(x.width).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.width.value).to eq("3")
expect(x.fixed).to eq(true)
end
# aggregation types
types.find{|x| x.id == "arrayType"}.type.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Types::Array)
- expect(x.bound1).to eq(1)
- expect(x.bound2).to eq(9)
+ expect(x.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.bound1.value).to eq("1")
+ expect(x.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.bound2.value).to eq("9")
expect(x.base_type).to be_instance_of(Expressir::Model::Types::String)
end
types.find{|x| x.id == "arrayOptionalType"}.type.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Types::Array)
- expect(x.bound1).to eq(1)
- expect(x.bound2).to eq(9)
+ expect(x.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.bound1.value).to eq("1")
+ expect(x.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.bound2.value).to eq("9")
expect(x.optional).to eq(true)
expect(x.base_type).to be_instance_of(Expressir::Model::Types::String)
end
types.find{|x| x.id == "arrayUniqueType"}.type.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Types::Array)
- expect(x.bound1).to eq(1)
- expect(x.bound2).to eq(9)
+ expect(x.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.bound1.value).to eq("1")
+ expect(x.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.bound2.value).to eq("9")
expect(x.unique).to eq(true)
expect(x.base_type).to be_instance_of(Expressir::Model::Types::String)
end
types.find{|x| x.id == "arrayOptionalUniqueType"}.type.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Types::Array)
- expect(x.bound1).to eq(1)
- expect(x.bound2).to eq(9)
+ expect(x.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.bound1.value).to eq("1")
+ expect(x.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.bound2.value).to eq("9")
expect(x.optional).to eq(true)
expect(x.unique).to eq(true)
expect(x.base_type).to be_instance_of(Expressir::Model::Types::String)
end
@@ -994,24 +1156,28 @@
expect(x.base_type).to be_instance_of(Expressir::Model::Types::String)
end
types.find{|x| x.id == "bagBoundType"}.type.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Types::Bag)
- expect(x.bound1).to eq(1)
- expect(x.bound2).to eq(9)
+ expect(x.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.bound1.value).to eq("1")
+ expect(x.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.bound2.value).to eq("9")
expect(x.base_type).to be_instance_of(Expressir::Model::Types::String)
end
types.find{|x| x.id == "listType"}.type.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Types::List)
expect(x.base_type).to be_instance_of(Expressir::Model::Types::String)
end
types.find{|x| x.id == "listBoundType"}.type.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Types::List)
- expect(x.bound1).to eq(1)
- expect(x.bound2).to eq(9)
+ expect(x.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.bound1.value).to eq("1")
+ expect(x.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.bound2.value).to eq("9")
expect(x.base_type).to be_instance_of(Expressir::Model::Types::String)
end
types.find{|x| x.id == "listUniqueType"}.type.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Types::List)
@@ -1019,12 +1185,14 @@
expect(x.base_type).to be_instance_of(Expressir::Model::Types::String)
end
types.find{|x| x.id == "listBoundUniqueType"}.type.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Types::List)
- expect(x.bound1).to eq(1)
- expect(x.bound2).to eq(9)
+ expect(x.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.bound1.value).to eq("1")
+ expect(x.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.bound2.value).to eq("9")
expect(x.unique).to eq(true)
expect(x.base_type).to be_instance_of(Expressir::Model::Types::String)
end
types.find{|x| x.id == "setType"}.type.tap do |x|
@@ -1032,12 +1200,14 @@
expect(x.base_type).to be_instance_of(Expressir::Model::Types::String)
end
types.find{|x| x.id == "setBoundType"}.type.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Types::Set)
- expect(x.bound1).to eq(1)
- expect(x.bound2).to eq(9)
+ expect(x.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.bound1.value).to eq("1")
+ expect(x.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.bound2.value).to eq("9")
expect(x.base_type).to be_instance_of(Expressir::Model::Types::String)
end
# constructed types
types.find{|x| x.id == "selectType"}.type.tap do |x|
@@ -1055,14 +1225,14 @@
expect(x.generic_entity).to eq(true)
end
types.find{|x| x.id == "selectListType"}.type.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Types::Select)
- expect(x.list).to be_instance_of(Array)
- expect(x.list.count).to eq(1)
- expect(x.list[0]).to be_instance_of(Expressir::Model::Ref)
- expect(x.list[0].id).to eq("test")
+ expect(x.items).to be_instance_of(Array)
+ expect(x.items.count).to eq(1)
+ expect(x.items[0]).to be_instance_of(Expressir::Model::Ref)
+ expect(x.items[0].id).to eq("test")
end
types.find{|x| x.id == "selectExtensionTypeRefType"}.type.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Types::Select)
expect(x.extension_type).to be_instance_of(Expressir::Model::Ref)
@@ -1071,14 +1241,14 @@
types.find{|x| x.id == "selectExtensionTypeRefListType"}.type.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Types::Select)
expect(x.extension_type).to be_instance_of(Expressir::Model::Ref)
expect(x.extension_type.id).to eq("selectType")
- expect(x.extension_list).to be_instance_of(Array)
- expect(x.extension_list.count).to eq(1)
- expect(x.extension_list[0]).to be_instance_of(Expressir::Model::Ref)
- expect(x.extension_list[0].id).to eq("test")
+ expect(x.extension_items).to be_instance_of(Array)
+ expect(x.extension_items.count).to eq(1)
+ expect(x.extension_items[0]).to be_instance_of(Expressir::Model::Ref)
+ expect(x.extension_items[0].id).to eq("test")
end
types.find{|x| x.id == "enumerationType"}.type.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Types::Enumeration)
end
@@ -1088,13 +1258,14 @@
expect(x.extensible).to eq(true)
end
types.find{|x| x.id == "enumerationListType"}.type.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Types::Enumeration)
- expect(x.list).to be_instance_of(Array)
- expect(x.list.count).to eq(1)
- expect(x.list[0]).to eq("test")
+ expect(x.items).to be_instance_of(Array)
+ expect(x.items.count).to eq(1)
+ expect(x.items[0]).to be_instance_of(Expressir::Model::EnumerationItem)
+ expect(x.items[0].id).to eq("test")
end
types.find{|x| x.id == "enumerationExtensionTypeRefType"}.type.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Types::Enumeration)
expect(x.extension_type).to be_instance_of(Expressir::Model::Ref)
@@ -1103,13 +1274,13 @@
types.find{|x| x.id == "enumerationExtensionTypeRefListType"}.type.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Types::Enumeration)
expect(x.extension_type).to be_instance_of(Expressir::Model::Ref)
expect(x.extension_type.id).to eq("enumerationType")
- expect(x.extension_list).to be_instance_of(Array)
- expect(x.extension_list.count).to eq(1)
- expect(x.extension_list[0]).to eq("test")
+ expect(x.extension_items).to be_instance_of(Array)
+ expect(x.extension_items[0]).to be_instance_of(Expressir::Model::EnumerationItem)
+ expect(x.extension_items[0].id).to eq("test")
end
# entities
entities.find{|x| x.id == "emptyEntity"}.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Entity)
@@ -1197,41 +1368,103 @@
expect(x.explicit[1]).to be_instance_of(Expressir::Model::Explicit)
expect(x.explicit[1].id).to eq("test2")
expect(x.explicit[1].type).to be_instance_of(Expressir::Model::Types::Boolean)
end
- entities.find{|x| x.id == "explicitAttributeRenamedEntity"}.tap do |x|
+ entities.find{|x| x.id == "explicitAttributeRedeclaredEntity"}.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Entity)
expect(x.explicit).to be_instance_of(Array)
expect(x.explicit.count).to eq(1)
expect(x.explicit[0]).to be_instance_of(Expressir::Model::Explicit)
- expect(x.explicit[0].id).to be_instance_of(Expressir::Model::RenamedRef)
- expect(x.explicit[0].id.ref).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
- expect(x.explicit[0].id.ref.ref).to be_instance_of(Expressir::Model::Ref)
- expect(x.explicit[0].id.ref.ref.id).to eq("SELF")
- expect(x.explicit[0].id.ref.qualifiers).to be_instance_of(Array)
- expect(x.explicit[0].id.ref.qualifiers.count).to eq(2)
- expect(x.explicit[0].id.ref.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::GroupQualifier)
- expect(x.explicit[0].id.ref.qualifiers[0].entity).to be_instance_of(Expressir::Model::Ref)
- expect(x.explicit[0].id.ref.qualifiers[0].entity.id).to eq("explicitAttributeEntity")
- expect(x.explicit[0].id.ref.qualifiers[1]).to be_instance_of(Expressir::Model::Expressions::AttributeQualifier)
- expect(x.explicit[0].id.ref.qualifiers[1].attribute).to be_instance_of(Expressir::Model::Ref)
- expect(x.explicit[0].id.ref.qualifiers[1].attribute.id).to eq("test")
- expect(x.explicit[0].id.id).to eq("test2")
+ expect(x.explicit[0].supertype_attribute).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
+ expect(x.explicit[0].supertype_attribute.ref).to be_instance_of(Expressir::Model::Ref)
+ expect(x.explicit[0].supertype_attribute.ref.id).to eq("SELF")
+ expect(x.explicit[0].supertype_attribute.qualifiers).to be_instance_of(Array)
+ expect(x.explicit[0].supertype_attribute.qualifiers.count).to eq(2)
+ expect(x.explicit[0].supertype_attribute.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::GroupQualifier)
+ expect(x.explicit[0].supertype_attribute.qualifiers[0].entity).to be_instance_of(Expressir::Model::Ref)
+ expect(x.explicit[0].supertype_attribute.qualifiers[0].entity.id).to eq("explicitAttributeEntity")
+ expect(x.explicit[0].supertype_attribute.qualifiers[1]).to be_instance_of(Expressir::Model::Expressions::AttributeQualifier)
+ expect(x.explicit[0].supertype_attribute.qualifiers[1].attribute).to be_instance_of(Expressir::Model::Ref)
+ expect(x.explicit[0].supertype_attribute.qualifiers[1].attribute.id).to eq("test")
expect(x.explicit[0].type).to be_instance_of(Expressir::Model::Types::Boolean)
end
+ entities.find{|x| x.id == "explicitAttributeRedeclaredRenamedEntity"}.tap do |x|
+ expect(x).to be_instance_of(Expressir::Model::Entity)
+ expect(x.explicit).to be_instance_of(Array)
+ expect(x.explicit.count).to eq(1)
+ expect(x.explicit[0]).to be_instance_of(Expressir::Model::Explicit)
+ expect(x.explicit[0].id).to eq("test2")
+ expect(x.explicit[0].supertype_attribute).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
+ expect(x.explicit[0].supertype_attribute.ref).to be_instance_of(Expressir::Model::Ref)
+ expect(x.explicit[0].supertype_attribute.ref.id).to eq("SELF")
+ expect(x.explicit[0].supertype_attribute.qualifiers).to be_instance_of(Array)
+ expect(x.explicit[0].supertype_attribute.qualifiers.count).to eq(2)
+ expect(x.explicit[0].supertype_attribute.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::GroupQualifier)
+ expect(x.explicit[0].supertype_attribute.qualifiers[0].entity).to be_instance_of(Expressir::Model::Ref)
+ expect(x.explicit[0].supertype_attribute.qualifiers[0].entity.id).to eq("explicitAttributeEntity")
+ expect(x.explicit[0].supertype_attribute.qualifiers[1]).to be_instance_of(Expressir::Model::Expressions::AttributeQualifier)
+ expect(x.explicit[0].supertype_attribute.qualifiers[1].attribute).to be_instance_of(Expressir::Model::Ref)
+ expect(x.explicit[0].supertype_attribute.qualifiers[1].attribute.id).to eq("test")
+ expect(x.explicit[0].type).to be_instance_of(Expressir::Model::Types::Boolean)
+ end
+
entities.find{|x| x.id == "derivedAttributeEntity"}.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Entity)
expect(x.derived).to be_instance_of(Array)
expect(x.derived.count).to eq(1)
expect(x.derived[0]).to be_instance_of(Expressir::Model::Derived)
expect(x.derived[0].id).to eq("test")
expect(x.derived[0].type).to be_instance_of(Expressir::Model::Types::Boolean)
- expect(x.derived[0].expression).to eq(true)
+ expect(x.derived[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.derived[0].expression.value).to eq(true)
end
+ entities.find{|x| x.id == "derivedAttributeRedeclaredEntity"}.tap do |x|
+ expect(x).to be_instance_of(Expressir::Model::Entity)
+ expect(x.derived).to be_instance_of(Array)
+ expect(x.derived.count).to eq(1)
+ expect(x.derived[0]).to be_instance_of(Expressir::Model::Derived)
+ expect(x.derived[0].supertype_attribute).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
+ expect(x.derived[0].supertype_attribute.ref).to be_instance_of(Expressir::Model::Ref)
+ expect(x.derived[0].supertype_attribute.ref.id).to eq("SELF")
+ expect(x.derived[0].supertype_attribute.qualifiers).to be_instance_of(Array)
+ expect(x.derived[0].supertype_attribute.qualifiers.count).to eq(2)
+ expect(x.derived[0].supertype_attribute.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::GroupQualifier)
+ expect(x.derived[0].supertype_attribute.qualifiers[0].entity).to be_instance_of(Expressir::Model::Ref)
+ expect(x.derived[0].supertype_attribute.qualifiers[0].entity.id).to eq("explicitAttributeEntity")
+ expect(x.derived[0].supertype_attribute.qualifiers[1]).to be_instance_of(Expressir::Model::Expressions::AttributeQualifier)
+ expect(x.derived[0].supertype_attribute.qualifiers[1].attribute).to be_instance_of(Expressir::Model::Ref)
+ expect(x.derived[0].supertype_attribute.qualifiers[1].attribute.id).to eq("test")
+ expect(x.derived[0].type).to be_instance_of(Expressir::Model::Types::Boolean)
+ expect(x.derived[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.derived[0].expression.value).to eq(true)
+ end
+
+ entities.find{|x| x.id == "derivedAttributeRedeclaredRenamedEntity"}.tap do |x|
+ expect(x).to be_instance_of(Expressir::Model::Entity)
+ expect(x.derived).to be_instance_of(Array)
+ expect(x.derived.count).to eq(1)
+ expect(x.derived[0]).to be_instance_of(Expressir::Model::Derived)
+ expect(x.derived[0].id).to eq("test2")
+ expect(x.derived[0].supertype_attribute).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
+ expect(x.derived[0].supertype_attribute.ref).to be_instance_of(Expressir::Model::Ref)
+ expect(x.derived[0].supertype_attribute.ref.id).to eq("SELF")
+ expect(x.derived[0].supertype_attribute.qualifiers).to be_instance_of(Array)
+ expect(x.derived[0].supertype_attribute.qualifiers.count).to eq(2)
+ expect(x.derived[0].supertype_attribute.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::GroupQualifier)
+ expect(x.derived[0].supertype_attribute.qualifiers[0].entity).to be_instance_of(Expressir::Model::Ref)
+ expect(x.derived[0].supertype_attribute.qualifiers[0].entity.id).to eq("explicitAttributeEntity")
+ expect(x.derived[0].supertype_attribute.qualifiers[1]).to be_instance_of(Expressir::Model::Expressions::AttributeQualifier)
+ expect(x.derived[0].supertype_attribute.qualifiers[1].attribute).to be_instance_of(Expressir::Model::Ref)
+ expect(x.derived[0].supertype_attribute.qualifiers[1].attribute.id).to eq("test")
+ expect(x.derived[0].type).to be_instance_of(Expressir::Model::Types::Boolean)
+ expect(x.derived[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.derived[0].expression.value).to eq(true)
+ end
+
entities.find{|x| x.id == "inverseAttributeEntity"}.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Entity)
expect(x.inverse).to be_instance_of(Array)
expect(x.inverse.count).to eq(1)
expect(x.inverse[0]).to be_instance_of(Expressir::Model::Inverse)
@@ -1278,12 +1511,14 @@
expect(x.inverse).to be_instance_of(Array)
expect(x.inverse.count).to eq(1)
expect(x.inverse[0]).to be_instance_of(Expressir::Model::Inverse)
expect(x.inverse[0].id).to eq("test")
expect(x.inverse[0].type).to be_instance_of(Expressir::Model::Types::Set)
- expect(x.inverse[0].type.bound1).to eq(1)
- expect(x.inverse[0].type.bound2).to eq(9)
+ expect(x.inverse[0].type.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.inverse[0].type.bound1.value).to eq("1")
+ expect(x.inverse[0].type.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.inverse[0].type.bound2.value).to eq("9")
expect(x.inverse[0].type.base_type).to be_instance_of(Expressir::Model::Ref)
expect(x.inverse[0].type.base_type.id).to eq("explicitAttributeEntity")
expect(x.inverse[0].attribute).to be_instance_of(Expressir::Model::Ref)
expect(x.inverse[0].attribute.id).to eq("test")
end
@@ -1306,18 +1541,65 @@
expect(x.inverse).to be_instance_of(Array)
expect(x.inverse.count).to eq(1)
expect(x.inverse[0]).to be_instance_of(Expressir::Model::Inverse)
expect(x.inverse[0].id).to eq("test")
expect(x.inverse[0].type).to be_instance_of(Expressir::Model::Types::Bag)
- expect(x.inverse[0].type.bound1).to eq(1)
- expect(x.inverse[0].type.bound2).to eq(9)
+ expect(x.inverse[0].type.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.inverse[0].type.bound1.value).to eq("1")
+ expect(x.inverse[0].type.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.inverse[0].type.bound2.value).to eq("9")
expect(x.inverse[0].type.base_type).to be_instance_of(Expressir::Model::Ref)
expect(x.inverse[0].type.base_type.id).to eq("explicitAttributeEntity")
expect(x.inverse[0].attribute).to be_instance_of(Expressir::Model::Ref)
expect(x.inverse[0].attribute.id).to eq("test")
end
+ entities.find{|x| x.id == "inverseAttributeRedeclaredEntity"}.tap do |x|
+ expect(x).to be_instance_of(Expressir::Model::Entity)
+ expect(x.inverse).to be_instance_of(Array)
+ expect(x.inverse.count).to eq(1)
+ expect(x.inverse[0]).to be_instance_of(Expressir::Model::Inverse)
+ expect(x.inverse[0].supertype_attribute).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
+ expect(x.inverse[0].supertype_attribute.ref).to be_instance_of(Expressir::Model::Ref)
+ expect(x.inverse[0].supertype_attribute.ref.id).to eq("SELF")
+ expect(x.inverse[0].supertype_attribute.qualifiers).to be_instance_of(Array)
+ expect(x.inverse[0].supertype_attribute.qualifiers.count).to eq(2)
+ expect(x.inverse[0].supertype_attribute.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::GroupQualifier)
+ expect(x.inverse[0].supertype_attribute.qualifiers[0].entity).to be_instance_of(Expressir::Model::Ref)
+ expect(x.inverse[0].supertype_attribute.qualifiers[0].entity.id).to eq("explicitAttributeEntity")
+ expect(x.inverse[0].supertype_attribute.qualifiers[1]).to be_instance_of(Expressir::Model::Expressions::AttributeQualifier)
+ expect(x.inverse[0].supertype_attribute.qualifiers[1].attribute).to be_instance_of(Expressir::Model::Ref)
+ expect(x.inverse[0].supertype_attribute.qualifiers[1].attribute.id).to eq("test")
+ expect(x.inverse[0].type).to be_instance_of(Expressir::Model::Ref)
+ expect(x.inverse[0].type.id).to eq("explicitAttributeEntity")
+ expect(x.inverse[0].attribute).to be_instance_of(Expressir::Model::Ref)
+ expect(x.inverse[0].attribute.id).to eq("test")
+ end
+
+ entities.find{|x| x.id == "inverseAttributeRedeclaredRenamedEntity"}.tap do |x|
+ expect(x).to be_instance_of(Expressir::Model::Entity)
+ expect(x.inverse).to be_instance_of(Array)
+ expect(x.inverse.count).to eq(1)
+ expect(x.inverse[0]).to be_instance_of(Expressir::Model::Inverse)
+ expect(x.inverse[0].id).to eq("test2")
+ expect(x.inverse[0].supertype_attribute).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
+ expect(x.inverse[0].supertype_attribute.ref).to be_instance_of(Expressir::Model::Ref)
+ expect(x.inverse[0].supertype_attribute.ref.id).to eq("SELF")
+ expect(x.inverse[0].supertype_attribute.qualifiers).to be_instance_of(Array)
+ expect(x.inverse[0].supertype_attribute.qualifiers.count).to eq(2)
+ expect(x.inverse[0].supertype_attribute.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::GroupQualifier)
+ expect(x.inverse[0].supertype_attribute.qualifiers[0].entity).to be_instance_of(Expressir::Model::Ref)
+ expect(x.inverse[0].supertype_attribute.qualifiers[0].entity.id).to eq("explicitAttributeEntity")
+ expect(x.inverse[0].supertype_attribute.qualifiers[1]).to be_instance_of(Expressir::Model::Expressions::AttributeQualifier)
+ expect(x.inverse[0].supertype_attribute.qualifiers[1].attribute).to be_instance_of(Expressir::Model::Ref)
+ expect(x.inverse[0].supertype_attribute.qualifiers[1].attribute.id).to eq("test")
+ expect(x.inverse[0].type).to be_instance_of(Expressir::Model::Ref)
+ expect(x.inverse[0].type.id).to eq("explicitAttributeEntity")
+ expect(x.inverse[0].attribute).to be_instance_of(Expressir::Model::Ref)
+ expect(x.inverse[0].attribute.id).to eq("test")
+ end
+
entities.find{|x| x.id == "uniqueEntity"}.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Entity)
expect(x.unique).to be_instance_of(Array)
expect(x.unique.count).to eq(1)
expect(x.unique[0]).to be_instance_of(Expressir::Model::Unique)
@@ -1395,20 +1677,22 @@
entities.find{|x| x.id == "whereEntity"}.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Entity)
expect(x.where).to be_instance_of(Array)
expect(x.where.count).to eq(1)
expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
- expect(x.where[0].expression).to eq(true)
+ expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.where[0].expression.value).to eq(true)
end
entities.find{|x| x.id == "whereLabelEntity"}.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Entity)
expect(x.where).to be_instance_of(Array)
expect(x.where.count).to eq(1)
expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
expect(x.where[0].id).to eq("WR1")
- expect(x.where[0].expression).to eq(true)
+ expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.where[0].expression.value).to eq(true)
end
# subtype constraints
subtype_constraints.find{|x| x.id == "emptySubtypeConstraint"}.tap do |x|
expect(x).to be_instance_of(Expressir::Model::SubtypeConstraint)
@@ -1768,11 +2052,12 @@
expect(x.constants).to be_instance_of(Array)
expect(x.constants.count).to eq(1)
expect(x.constants[0]).to be_instance_of(Expressir::Model::Constant)
expect(x.constants[0].id).to eq("test")
expect(x.constants[0].type).to be_instance_of(Expressir::Model::Types::String)
- expect(x.constants[0].expression).to eq("xxx")
+ expect(x.constants[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+ expect(x.constants[0].expression.value).to eq("xxx")
expect(x.statements).to be_instance_of(Array)
expect(x.statements.count).to eq(1)
expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
end
@@ -1782,15 +2067,17 @@
expect(x.constants).to be_instance_of(Array)
expect(x.constants.count).to eq(2)
expect(x.constants[0]).to be_instance_of(Expressir::Model::Constant)
expect(x.constants[0].id).to eq("test")
expect(x.constants[0].type).to be_instance_of(Expressir::Model::Types::String)
- expect(x.constants[0].expression).to eq("xxx")
+ expect(x.constants[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+ expect(x.constants[0].expression.value).to eq("xxx")
expect(x.constants[1]).to be_instance_of(Expressir::Model::Constant)
expect(x.constants[1].id).to eq("test2")
expect(x.constants[1].type).to be_instance_of(Expressir::Model::Types::String)
- expect(x.constants[1].expression).to eq("xxx")
+ expect(x.constants[1].expression).to be_instance_of(Expressir::Model::Literals::String)
+ expect(x.constants[1].expression.value).to eq("xxx")
expect(x.statements).to be_instance_of(Array)
expect(x.statements.count).to eq(1)
expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
end
@@ -1845,11 +2132,12 @@
expect(x.locals).to be_instance_of(Array)
expect(x.locals.count).to eq(1)
expect(x.locals[0]).to be_instance_of(Expressir::Model::Local)
expect(x.locals[0].id).to eq("test")
expect(x.locals[0].type).to be_instance_of(Expressir::Model::Types::String)
- expect(x.locals[0].expression).to eq("xxx")
+ expect(x.locals[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+ expect(x.locals[0].expression.value).to eq("xxx")
expect(x.statements).to be_instance_of(Array)
expect(x.statements.count).to eq(1)
expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
end
@@ -1859,15 +2147,17 @@
expect(x.locals).to be_instance_of(Array)
expect(x.locals.count).to eq(2)
expect(x.locals[0]).to be_instance_of(Expressir::Model::Local)
expect(x.locals[0].id).to eq("test")
expect(x.locals[0].type).to be_instance_of(Expressir::Model::Types::String)
- expect(x.locals[0].expression).to eq("xxx")
+ expect(x.locals[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+ expect(x.locals[0].expression.value).to eq("xxx")
expect(x.locals[1]).to be_instance_of(Expressir::Model::Local)
expect(x.locals[1].id).to eq("test2")
expect(x.locals[1].type).to be_instance_of(Expressir::Model::Types::String)
- expect(x.locals[1].expression).to eq("xxx")
+ expect(x.locals[1].expression).to be_instance_of(Expressir::Model::Literals::String)
+ expect(x.locals[1].expression.value).to eq("xxx")
expect(x.statements).to be_instance_of(Array)
expect(x.statements.count).to eq(1)
expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
end
@@ -1877,15 +2167,17 @@
expect(x.locals).to be_instance_of(Array)
expect(x.locals.count).to eq(2)
expect(x.locals[0]).to be_instance_of(Expressir::Model::Local)
expect(x.locals[0].id).to eq("test")
expect(x.locals[0].type).to be_instance_of(Expressir::Model::Types::String)
- expect(x.locals[0].expression).to eq("xxx")
+ expect(x.locals[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+ expect(x.locals[0].expression.value).to eq("xxx")
expect(x.locals[1]).to be_instance_of(Expressir::Model::Local)
expect(x.locals[1].id).to eq("test2")
expect(x.locals[1].type).to be_instance_of(Expressir::Model::Types::String)
- expect(x.locals[1].expression).to eq("xxx")
+ expect(x.locals[1].expression).to be_instance_of(Expressir::Model::Literals::String)
+ expect(x.locals[1].expression.value).to eq("xxx")
expect(x.statements).to be_instance_of(Array)
expect(x.statements.count).to eq(1)
expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
end
@@ -1998,25 +2290,28 @@
expect(x.constants).to be_instance_of(Array)
expect(x.constants.count).to eq(1)
expect(x.constants[0]).to be_instance_of(Expressir::Model::Constant)
expect(x.constants[0].id).to eq("test")
expect(x.constants[0].type).to be_instance_of(Expressir::Model::Types::String)
- expect(x.constants[0].expression).to eq("xxx")
+ expect(x.constants[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+ expect(x.constants[0].expression.value).to eq("xxx")
end
procedures.find{|x| x.id == "multipleConstantProcedure"}.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Procedure)
expect(x.constants).to be_instance_of(Array)
expect(x.constants.count).to eq(2)
expect(x.constants[0]).to be_instance_of(Expressir::Model::Constant)
expect(x.constants[0].id).to eq("test")
expect(x.constants[0].type).to be_instance_of(Expressir::Model::Types::String)
- expect(x.constants[0].expression).to eq("xxx")
+ expect(x.constants[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+ expect(x.constants[0].expression.value).to eq("xxx")
expect(x.constants[1]).to be_instance_of(Expressir::Model::Constant)
expect(x.constants[1].id).to eq("test2")
expect(x.constants[1].type).to be_instance_of(Expressir::Model::Types::String)
- expect(x.constants[1].expression).to eq("xxx")
+ expect(x.constants[1].expression).to be_instance_of(Expressir::Model::Literals::String)
+ expect(x.constants[1].expression.value).to eq("xxx")
end
procedures.find{|x| x.id == "localProcedure"}.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Procedure)
expect(x.locals).to be_instance_of(Array)
@@ -2055,39 +2350,44 @@
expect(x.locals).to be_instance_of(Array)
expect(x.locals.count).to eq(1)
expect(x.locals[0]).to be_instance_of(Expressir::Model::Local)
expect(x.locals[0].id).to eq("test")
expect(x.locals[0].type).to be_instance_of(Expressir::Model::Types::String)
- expect(x.locals[0].expression).to eq("xxx")
+ expect(x.locals[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+ expect(x.locals[0].expression.value).to eq("xxx")
end
procedures.find{|x| x.id == "multipleLocalExpressionProcedure"}.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Procedure)
expect(x.locals).to be_instance_of(Array)
expect(x.locals.count).to eq(2)
expect(x.locals[0]).to be_instance_of(Expressir::Model::Local)
expect(x.locals[0].id).to eq("test")
expect(x.locals[0].type).to be_instance_of(Expressir::Model::Types::String)
- expect(x.locals[0].expression).to eq("xxx")
+ expect(x.locals[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+ expect(x.locals[0].expression.value).to eq("xxx")
expect(x.locals[1]).to be_instance_of(Expressir::Model::Local)
expect(x.locals[1].id).to eq("test2")
expect(x.locals[1].type).to be_instance_of(Expressir::Model::Types::String)
- expect(x.locals[1].expression).to eq("xxx")
+ expect(x.locals[1].expression).to be_instance_of(Expressir::Model::Literals::String)
+ expect(x.locals[1].expression.value).to eq("xxx")
end
procedures.find{|x| x.id == "multipleShorthandLocalExpressionProcedure"}.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Procedure)
expect(x.locals).to be_instance_of(Array)
expect(x.locals.count).to eq(2)
expect(x.locals[0]).to be_instance_of(Expressir::Model::Local)
expect(x.locals[0].id).to eq("test")
expect(x.locals[0].type).to be_instance_of(Expressir::Model::Types::String)
- expect(x.locals[0].expression).to eq("xxx")
+ expect(x.locals[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+ expect(x.locals[0].expression.value).to eq("xxx")
expect(x.locals[1]).to be_instance_of(Expressir::Model::Local)
expect(x.locals[1].id).to eq("test2")
expect(x.locals[1].type).to be_instance_of(Expressir::Model::Types::String)
- expect(x.locals[1].expression).to eq("xxx")
+ expect(x.locals[1].expression).to be_instance_of(Expressir::Model::Literals::String)
+ expect(x.locals[1].expression.value).to eq("xxx")
end
# rules
rules.find{|x| x.id == "emptyRule"}.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Rule)
@@ -2096,11 +2396,12 @@
expect(x.applies_to[0]).to be_instance_of(Expressir::Model::Ref)
expect(x.applies_to[0].id).to eq("emptyEntity")
expect(x.where).to be_instance_of(Array)
expect(x.where.count).to eq(1)
expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
- expect(x.where[0].expression).to eq(true)
+ expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.where[0].expression.value).to eq(true)
end
rules.find{|x| x.id == "typeRule"}.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Rule)
expect(x.applies_to).to be_instance_of(Array)
@@ -2113,11 +2414,12 @@
expect(x.declarations[0].id).to eq("integerType")
expect(x.declarations[0].type).to be_instance_of(Expressir::Model::Types::Integer)
expect(x.where).to be_instance_of(Array)
expect(x.where.count).to eq(1)
expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
- expect(x.where[0].expression).to eq(true)
+ expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.where[0].expression.value).to eq(true)
end
rules.find{|x| x.id == "constantRule"}.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Rule)
expect(x.applies_to).to be_instance_of(Array)
@@ -2127,15 +2429,17 @@
expect(x.constants).to be_instance_of(Array)
expect(x.constants.count).to eq(1)
expect(x.constants[0]).to be_instance_of(Expressir::Model::Constant)
expect(x.constants[0].id).to eq("test")
expect(x.constants[0].type).to be_instance_of(Expressir::Model::Types::String)
- expect(x.constants[0].expression).to eq("xxx")
+ expect(x.constants[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+ expect(x.constants[0].expression.value).to eq("xxx")
expect(x.where).to be_instance_of(Array)
expect(x.where.count).to eq(1)
expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
- expect(x.where[0].expression).to eq(true)
+ expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.where[0].expression.value).to eq(true)
end
rules.find{|x| x.id == "multipleConstantRule"}.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Rule)
expect(x.applies_to).to be_instance_of(Array)
@@ -2145,19 +2449,22 @@
expect(x.constants).to be_instance_of(Array)
expect(x.constants.count).to eq(2)
expect(x.constants[0]).to be_instance_of(Expressir::Model::Constant)
expect(x.constants[0].id).to eq("test")
expect(x.constants[0].type).to be_instance_of(Expressir::Model::Types::String)
- expect(x.constants[0].expression).to eq("xxx")
+ expect(x.constants[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+ expect(x.constants[0].expression.value).to eq("xxx")
expect(x.constants[1]).to be_instance_of(Expressir::Model::Constant)
expect(x.constants[1].id).to eq("test2")
expect(x.constants[1].type).to be_instance_of(Expressir::Model::Types::String)
- expect(x.constants[1].expression).to eq("xxx")
+ expect(x.constants[1].expression).to be_instance_of(Expressir::Model::Literals::String)
+ expect(x.constants[1].expression.value).to eq("xxx")
expect(x.where).to be_instance_of(Array)
expect(x.where.count).to eq(1)
expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
- expect(x.where[0].expression).to eq(true)
+ expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.where[0].expression.value).to eq(true)
end
rules.find{|x| x.id == "localRule"}.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Rule)
expect(x.applies_to).to be_instance_of(Array)
@@ -2170,11 +2477,12 @@
expect(x.locals[0].id).to eq("test")
expect(x.locals[0].type).to be_instance_of(Expressir::Model::Types::String)
expect(x.where).to be_instance_of(Array)
expect(x.where.count).to eq(1)
expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
- expect(x.where[0].expression).to eq(true)
+ expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.where[0].expression.value).to eq(true)
end
rules.find{|x| x.id == "multipleLocalRule"}.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Rule)
expect(x.applies_to).to be_instance_of(Array)
@@ -2190,11 +2498,12 @@
expect(x.locals[1].id).to eq("test2")
expect(x.locals[1].type).to be_instance_of(Expressir::Model::Types::String)
expect(x.where).to be_instance_of(Array)
expect(x.where.count).to eq(1)
expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
- expect(x.where[0].expression).to eq(true)
+ expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.where[0].expression.value).to eq(true)
end
rules.find{|x| x.id == "multipleShorthandLocalRule"}.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Rule)
expect(x.applies_to).to be_instance_of(Array)
@@ -2210,11 +2519,12 @@
expect(x.locals[1].id).to eq("test2")
expect(x.locals[1].type).to be_instance_of(Expressir::Model::Types::String)
expect(x.where).to be_instance_of(Array)
expect(x.where.count).to eq(1)
expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
- expect(x.where[0].expression).to eq(true)
+ expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.where[0].expression.value).to eq(true)
end
rules.find{|x| x.id == "localExpressionRule"}.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Rule)
expect(x.applies_to).to be_instance_of(Array)
@@ -2224,15 +2534,17 @@
expect(x.locals).to be_instance_of(Array)
expect(x.locals.count).to eq(1)
expect(x.locals[0]).to be_instance_of(Expressir::Model::Local)
expect(x.locals[0].id).to eq("test")
expect(x.locals[0].type).to be_instance_of(Expressir::Model::Types::String)
- expect(x.locals[0].expression).to eq("xxx")
+ expect(x.locals[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+ expect(x.locals[0].expression.value).to eq("xxx")
expect(x.where).to be_instance_of(Array)
expect(x.where.count).to eq(1)
expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
- expect(x.where[0].expression).to eq(true)
+ expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.where[0].expression.value).to eq(true)
end
rules.find{|x| x.id == "multipleLocalExpressionRule"}.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Rule)
expect(x.applies_to).to be_instance_of(Array)
@@ -2242,19 +2554,22 @@
expect(x.locals).to be_instance_of(Array)
expect(x.locals.count).to eq(2)
expect(x.locals[0]).to be_instance_of(Expressir::Model::Local)
expect(x.locals[0].id).to eq("test")
expect(x.locals[0].type).to be_instance_of(Expressir::Model::Types::String)
- expect(x.locals[0].expression).to eq("xxx")
+ expect(x.locals[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+ expect(x.locals[0].expression.value).to eq("xxx")
expect(x.locals[1]).to be_instance_of(Expressir::Model::Local)
expect(x.locals[1].id).to eq("test2")
expect(x.locals[1].type).to be_instance_of(Expressir::Model::Types::String)
- expect(x.locals[1].expression).to eq("xxx")
+ expect(x.locals[1].expression).to be_instance_of(Expressir::Model::Literals::String)
+ expect(x.locals[1].expression.value).to eq("xxx")
expect(x.where).to be_instance_of(Array)
expect(x.where.count).to eq(1)
expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
- expect(x.where[0].expression).to eq(true)
+ expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.where[0].expression.value).to eq(true)
end
rules.find{|x| x.id == "multipleShorthandLocalExpressionRule"}.tap do |x|
expect(x).to be_instance_of(Expressir::Model::Rule)
expect(x.applies_to).to be_instance_of(Array)
@@ -2264,19 +2579,22 @@
expect(x.locals).to be_instance_of(Array)
expect(x.locals.count).to eq(2)
expect(x.locals[0]).to be_instance_of(Expressir::Model::Local)
expect(x.locals[0].id).to eq("test")
expect(x.locals[0].type).to be_instance_of(Expressir::Model::Types::String)
- expect(x.locals[0].expression).to eq("xxx")
+ expect(x.locals[0].expression).to be_instance_of(Expressir::Model::Literals::String)
+ expect(x.locals[0].expression.value).to eq("xxx")
expect(x.locals[1]).to be_instance_of(Expressir::Model::Local)
expect(x.locals[1].id).to eq("test2")
expect(x.locals[1].type).to be_instance_of(Expressir::Model::Types::String)
- expect(x.locals[1].expression).to eq("xxx")
+ expect(x.locals[1].expression).to be_instance_of(Expressir::Model::Literals::String)
+ expect(x.locals[1].expression.value).to eq("xxx")
expect(x.where).to be_instance_of(Array)
expect(x.where.count).to eq(1)
expect(x.where[0]).to be_instance_of(Expressir::Model::Where)
- expect(x.where[0].expression).to eq(true)
+ expect(x.where[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.where[0].expression.value).to eq(true)
end
# statements
functions.find{|x| x.id == "aliasStatement"}.statements[0].tap do |x|
expect(x).to be_instance_of(Expressir::Model::Statements::Alias)
@@ -2327,11 +2645,12 @@
expect(x.expression.ref).to be_instance_of(Expressir::Model::Ref)
expect(x.expression.ref.id).to eq("test")
expect(x.expression.qualifiers).to be_instance_of(Array)
expect(x.expression.qualifiers.count).to eq(1)
expect(x.expression.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::IndexQualifier)
- expect(x.expression.qualifiers[0].index1).to eq(1)
+ expect(x.expression.qualifiers[0].index1).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.expression.qualifiers[0].index1.value).to eq("1")
expect(x.statements).to be_instance_of(Array)
expect(x.statements.count).to eq(1)
expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
end
@@ -2342,22 +2661,25 @@
expect(x.expression.ref).to be_instance_of(Expressir::Model::Ref)
expect(x.expression.ref.id).to eq("test")
expect(x.expression.qualifiers).to be_instance_of(Array)
expect(x.expression.qualifiers.count).to eq(1)
expect(x.expression.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::IndexQualifier)
- expect(x.expression.qualifiers[0].index1).to eq(1)
- expect(x.expression.qualifiers[0].index2).to eq(9)
+ expect(x.expression.qualifiers[0].index1).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.expression.qualifiers[0].index1.value).to eq("1")
+ expect(x.expression.qualifiers[0].index2).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.expression.qualifiers[0].index2.value).to eq("9")
expect(x.statements).to be_instance_of(Array)
expect(x.statements.count).to eq(1)
expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
end
functions.find{|x| x.id == "assignmentStatement"}.statements[0].tap do |x|
expect(x).to be_instance_of(Expressir::Model::Statements::Assignment)
expect(x.ref).to be_instance_of(Expressir::Model::Ref)
expect(x.ref.id).to eq("test")
- expect(x.expression).to eq(true)
+ expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.expression.value).to eq(true)
end
functions.find{|x| x.id == "assignmentAttributeStatement"}.statements[0].tap do |x|
expect(x).to be_instance_of(Expressir::Model::Statements::Assignment)
expect(x.ref).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
@@ -2366,11 +2688,12 @@
expect(x.ref.qualifiers).to be_instance_of(Array)
expect(x.ref.qualifiers.count).to eq(1)
expect(x.ref.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::AttributeQualifier)
expect(x.ref.qualifiers[0].attribute).to be_instance_of(Expressir::Model::Ref)
expect(x.ref.qualifiers[0].attribute.id).to eq("test")
- expect(x.expression).to eq(true)
+ expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.expression.value).to eq(true)
end
functions.find{|x| x.id == "assignmentGroupStatement"}.statements[0].tap do |x|
expect(x).to be_instance_of(Expressir::Model::Statements::Assignment)
expect(x.ref).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
@@ -2379,85 +2702,97 @@
expect(x.ref.qualifiers).to be_instance_of(Array)
expect(x.ref.qualifiers.count).to eq(1)
expect(x.ref.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::GroupQualifier)
expect(x.ref.qualifiers[0].entity).to be_instance_of(Expressir::Model::Ref)
expect(x.ref.qualifiers[0].entity.id).to eq("test")
- expect(x.expression).to eq(true)
+ expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.expression.value).to eq(true)
end
functions.find{|x| x.id == "assignmentIndexStatement"}.statements[0].tap do |x|
expect(x).to be_instance_of(Expressir::Model::Statements::Assignment)
expect(x.ref).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
expect(x.ref.ref).to be_instance_of(Expressir::Model::Ref)
expect(x.ref.ref.id).to eq("test")
expect(x.ref.qualifiers).to be_instance_of(Array)
expect(x.ref.qualifiers.count).to eq(1)
expect(x.ref.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::IndexQualifier)
- expect(x.ref.qualifiers[0].index1).to eq(1)
- expect(x.expression).to eq(true)
+ expect(x.ref.qualifiers[0].index1).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.ref.qualifiers[0].index1.value).to eq("1")
+ expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.expression.value).to eq(true)
end
functions.find{|x| x.id == "assignmentIndex2Statement"}.statements[0].tap do |x|
expect(x).to be_instance_of(Expressir::Model::Statements::Assignment)
expect(x.ref).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
expect(x.ref.ref).to be_instance_of(Expressir::Model::Ref)
expect(x.ref.ref.id).to eq("test")
expect(x.ref.qualifiers).to be_instance_of(Array)
expect(x.ref.qualifiers.count).to eq(1)
expect(x.ref.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::IndexQualifier)
- expect(x.ref.qualifiers[0].index1).to eq(1)
- expect(x.ref.qualifiers[0].index2).to eq(9)
- expect(x.expression).to eq(true)
+ expect(x.ref.qualifiers[0].index1).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.ref.qualifiers[0].index1.value).to eq("1")
+ expect(x.ref.qualifiers[0].index2).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.ref.qualifiers[0].index2.value).to eq("9")
+ expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.expression.value).to eq(true)
end
functions.find{|x| x.id == "caseStatement"}.statements[0].tap do |x|
expect(x).to be_instance_of(Expressir::Model::Statements::Case)
expect(x.selector).to be_instance_of(Expressir::Model::Ref)
expect(x.selector.id).to eq("test")
expect(x.actions).to be_instance_of(Array)
expect(x.actions.count).to eq(1)
expect(x.actions[0]).to be_instance_of(Expressir::Model::Statements::CaseAction)
- expect(x.actions[0].label).to eq(true)
+ expect(x.actions[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.actions[0].expression.value).to eq(true)
expect(x.actions[0].statement).to be_instance_of(Expressir::Model::Statements::Null)
end
functions.find{|x| x.id == "caseMultipleStatement"}.statements[0].tap do |x|
expect(x).to be_instance_of(Expressir::Model::Statements::Case)
expect(x.selector).to be_instance_of(Expressir::Model::Ref)
expect(x.selector.id).to eq("test")
expect(x.actions).to be_instance_of(Array)
expect(x.actions.count).to eq(2)
expect(x.actions[0]).to be_instance_of(Expressir::Model::Statements::CaseAction)
- expect(x.actions[0].label).to eq(true)
+ expect(x.actions[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.actions[0].expression.value).to eq(true)
expect(x.actions[0].statement).to be_instance_of(Expressir::Model::Statements::Null)
expect(x.actions[1]).to be_instance_of(Expressir::Model::Statements::CaseAction)
- expect(x.actions[1].label).to eq(true)
+ expect(x.actions[1].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.actions[1].expression.value).to eq(true)
expect(x.actions[1].statement).to be_instance_of(Expressir::Model::Statements::Null)
end
functions.find{|x| x.id == "caseMultipleShorthandStatement"}.statements[0].tap do |x|
expect(x).to be_instance_of(Expressir::Model::Statements::Case)
expect(x.selector).to be_instance_of(Expressir::Model::Ref)
expect(x.selector.id).to eq("test")
expect(x.actions).to be_instance_of(Array)
expect(x.actions.count).to eq(2)
expect(x.actions[0]).to be_instance_of(Expressir::Model::Statements::CaseAction)
- expect(x.actions[0].label).to eq(true)
+ expect(x.actions[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.actions[0].expression.value).to eq(true)
expect(x.actions[0].statement).to be_instance_of(Expressir::Model::Statements::Null)
expect(x.actions[1]).to be_instance_of(Expressir::Model::Statements::CaseAction)
- expect(x.actions[1].label).to eq(true)
+ expect(x.actions[1].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.actions[1].expression.value).to eq(true)
expect(x.actions[1].statement).to be_instance_of(Expressir::Model::Statements::Null)
end
functions.find{|x| x.id == "caseOtherwiseStatement"}.statements[0].tap do |x|
expect(x).to be_instance_of(Expressir::Model::Statements::Case)
expect(x.selector).to be_instance_of(Expressir::Model::Ref)
expect(x.selector.id).to eq("test")
expect(x.actions).to be_instance_of(Array)
expect(x.actions.count).to eq(1)
expect(x.actions[0]).to be_instance_of(Expressir::Model::Statements::CaseAction)
- expect(x.actions[0].label).to eq(true)
+ expect(x.actions[0].expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.actions[0].expression.value).to eq(true)
expect(x.actions[0].statement).to be_instance_of(Expressir::Model::Statements::Null)
expect(x.otherwise_statement).to be_instance_of(Expressir::Model::Statements::Null)
end
functions.find{|x| x.id == "compoundStatement"}.statements[0].tap do |x|
@@ -2471,39 +2806,43 @@
expect(x).to be_instance_of(Expressir::Model::Statements::Escape)
end
functions.find{|x| x.id == "ifStatement"}.statements[0].tap do |x|
expect(x).to be_instance_of(Expressir::Model::Statements::If)
- expect(x.condition).to eq(true)
+ expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.expression.value).to eq(true)
expect(x.statements).to be_instance_of(Array)
expect(x.statements.count).to eq(1)
expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
end
functions.find{|x| x.id == "if2Statement"}.statements[0].tap do |x|
expect(x).to be_instance_of(Expressir::Model::Statements::If)
- expect(x.condition).to eq(true)
+ expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.expression.value).to eq(true)
expect(x.statements).to be_instance_of(Array)
expect(x.statements.count).to eq(2)
expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
expect(x.statements[1]).to be_instance_of(Expressir::Model::Statements::Null)
end
functions.find{|x| x.id == "ifElseStatement"}.statements[0].tap do |x|
expect(x).to be_instance_of(Expressir::Model::Statements::If)
- expect(x.condition).to eq(true)
+ expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.expression.value).to eq(true)
expect(x.statements).to be_instance_of(Array)
expect(x.statements.count).to eq(1)
expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
expect(x.else_statements).to be_instance_of(Array)
expect(x.else_statements.count).to eq(1)
expect(x.else_statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
end
functions.find{|x| x.id == "if2ElseStatement"}.statements[0].tap do |x|
expect(x).to be_instance_of(Expressir::Model::Statements::If)
- expect(x.condition).to eq(true)
+ expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.expression.value).to eq(true)
expect(x.statements).to be_instance_of(Array)
expect(x.statements.count).to eq(2)
expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
expect(x.statements[1]).to be_instance_of(Expressir::Model::Statements::Null)
expect(x.else_statements).to be_instance_of(Array)
@@ -2511,11 +2850,12 @@
expect(x.else_statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
end
functions.find{|x| x.id == "ifElse2Statement"}.statements[0].tap do |x|
expect(x).to be_instance_of(Expressir::Model::Statements::If)
- expect(x.condition).to eq(true)
+ expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.expression.value).to eq(true)
expect(x.statements).to be_instance_of(Array)
expect(x.statements.count).to eq(1)
expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
expect(x.else_statements).to be_instance_of(Array)
expect(x.else_statements.count).to eq(2)
@@ -2523,11 +2863,12 @@
expect(x.else_statements[1]).to be_instance_of(Expressir::Model::Statements::Null)
end
functions.find{|x| x.id == "if2Else2Statement"}.statements[0].tap do |x|
expect(x).to be_instance_of(Expressir::Model::Statements::If)
- expect(x.condition).to eq(true)
+ expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.expression.value).to eq(true)
expect(x.statements).to be_instance_of(Array)
expect(x.statements.count).to eq(2)
expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
expect(x.statements[1]).to be_instance_of(Expressir::Model::Statements::Null)
expect(x.else_statements).to be_instance_of(Array)
@@ -2550,21 +2891,24 @@
expect(x).to be_instance_of(Expressir::Model::Statements::ProcedureCall)
expect(x.procedure).to be_instance_of(Expressir::Model::Ref)
expect(x.procedure.id).to eq("emptyProcedure")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(1)
- expect(x.parameters[0]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
end
functions.find{|x| x.id == "procedureCallParameter2Statement"}.statements[0].tap do |x|
expect(x).to be_instance_of(Expressir::Model::Statements::ProcedureCall)
expect(x.procedure).to be_instance_of(Expressir::Model::Ref)
expect(x.procedure.id).to eq("emptyProcedure")
expect(x.parameters).to be_instance_of(Array)
expect(x.parameters.count).to eq(2)
- expect(x.parameters[0]).to eq(true)
- expect(x.parameters[1]).to eq(true)
+ expect(x.parameters[0]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[0].value).to eq(true)
+ expect(x.parameters[1]).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.parameters[1].value).to eq(true)
end
functions.find{|x| x.id == "procedureCallInsertStatement"}.statements[0].tap do |x|
expect(x).to be_instance_of(Expressir::Model::Statements::ProcedureCall)
expect(x.procedure).to be_instance_of(Expressir::Model::Ref)
@@ -2584,47 +2928,55 @@
expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
end
functions.find{|x| x.id == "repeatVariableStatement"}.statements[0].tap do |x|
expect(x).to be_instance_of(Expressir::Model::Statements::Repeat)
- expect(x.variable).to eq("test")
- expect(x.bound1).to eq(1)
- expect(x.bound2).to eq(9)
+ expect(x.id).to eq("test")
+ expect(x.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.bound1.value).to eq("1")
+ expect(x.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.bound2.value).to eq("9")
expect(x.statements).to be_instance_of(Array)
expect(x.statements.count).to eq(1)
expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
end
functions.find{|x| x.id == "repeatVariableIncrementStatement"}.statements[0].tap do |x|
expect(x).to be_instance_of(Expressir::Model::Statements::Repeat)
- expect(x.variable).to eq("test")
- expect(x.bound1).to eq(1)
- expect(x.bound2).to eq(9)
- expect(x.increment).to eq(2)
+ expect(x.id).to eq("test")
+ expect(x.bound1).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.bound1.value).to eq("1")
+ expect(x.bound2).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.bound2.value).to eq("9")
+ expect(x.increment).to be_instance_of(Expressir::Model::Literals::Integer)
+ expect(x.increment.value).to eq("2")
expect(x.statements).to be_instance_of(Array)
expect(x.statements.count).to eq(1)
expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
end
functions.find{|x| x.id == "repeatWhileStatement"}.statements[0].tap do |x|
expect(x).to be_instance_of(Expressir::Model::Statements::Repeat)
- expect(x.while_expression).to eq(true)
+ expect(x.while_expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.while_expression.value).to eq(true)
expect(x.statements).to be_instance_of(Array)
expect(x.statements.count).to eq(1)
expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
end
functions.find{|x| x.id == "repeatUntilStatement"}.statements[0].tap do |x|
expect(x).to be_instance_of(Expressir::Model::Statements::Repeat)
- expect(x.until_expression).to eq(true)
+ expect(x.until_expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.until_expression.value).to eq(true)
expect(x.statements).to be_instance_of(Array)
expect(x.statements.count).to eq(1)
expect(x.statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
end
functions.find{|x| x.id == "returnStatement"}.statements[0].tap do |x|
expect(x).to be_instance_of(Expressir::Model::Statements::Return)
- expect(x.expression).to eq(true)
+ expect(x.expression).to be_instance_of(Expressir::Model::Literals::Logical)
+ expect(x.expression.value).to eq(true)
end
functions.find{|x| x.id == "skipStatement"}.statements[0].tap do |x|
expect(x).to be_instance_of(Expressir::Model::Statements::Skip)
end