expressir 0.2.0 → 0.2.5

data/lib/expressir/model/expressions/unknown.rb

@@ -1,8 +0,0 @@
-module Expressir
-  module Model
-    module Expressions
-      class Unknown
-      end
-    end
-  end
-end

data/lib/expressir/model/inverse.rb

@@ -1,15 +0,0 @@
-module Expressir
-  module Model
-    class Inverse
-      attr_accessor :id
-      attr_accessor :type
-      attr_accessor :attribute
-
-      def initialize(options = {})
-        @id = options[:id]
-        @type = options[:type]
-        @attribute = options[:attribute]
-      end
-    end
-  end
-end

data/lib/expressir/model/local.rb

@@ -1,15 +0,0 @@
-module Expressir
-  module Model
-    class Local
-      attr_accessor :id
-      attr_accessor :type
-      attr_accessor :expression
-
-      def initialize(options = {})
-        @id = options[:id]
-        @type = options[:type]
-        @expression = options[:expression]
-      end
-    end
-  end
-end

data/lib/expressir/model/operators/addition.rb

@@ -1,8 +0,0 @@
-module Expressir
-  module Model
-    module Operators
-      class Addition
-      end
-    end
-  end
-end

data/lib/expressir/model/operators/and.rb

@@ -1,8 +0,0 @@
-module Expressir
-  module Model
-    module Operators
-      class And
-      end
-    end
-  end
-end

data/lib/expressir/model/operators/andor.rb

@@ -1,8 +0,0 @@
-module Expressir
-  module Model
-    module Operators
-      class Andor
-      end
-    end
-  end
-end

data/lib/expressir/model/operators/combine.rb

@@ -1,8 +0,0 @@
-module Expressir
-  module Model
-    module Operators
-      class Combine
-      end
-    end
-  end
-end

data/lib/expressir/model/operators/equal.rb

@@ -1,8 +0,0 @@
-module Expressir
-  module Model
-    module Operators
-      class Equal
-      end
-    end
-  end
-end

data/lib/expressir/model/operators/exponentiation.rb

@@ -1,8 +0,0 @@
-module Expressir
-  module Model
-    module Operators
-      class Exponentiation
-      end
-    end
-  end
-end

data/lib/expressir/model/operators/greater_than.rb

@@ -1,8 +0,0 @@
-module Expressir
-  module Model
-    module Operators
-      class GreaterThan
-      end
-    end
-  end
-end

data/lib/expressir/model/operators/greater_than_or_equal.rb

@@ -1,8 +0,0 @@
-module Expressir
-  module Model
-    module Operators
-      class GreaterThanOrEqual
-      end
-    end
-  end
-end

data/lib/expressir/model/operators/in.rb

@@ -1,8 +0,0 @@
-module Expressir
-  module Model
-    module Operators
-      class In
-      end
-    end
-  end
-end

data/lib/expressir/model/operators/instance_equal.rb

@@ -1,8 +0,0 @@
-module Expressir
-  module Model
-    module Operators
-      class InstanceEqual
-      end
-    end
-  end
-end

data/lib/expressir/model/operators/instance_not_equal.rb

@@ -1,8 +0,0 @@
-module Expressir
-  module Model
-    module Operators
-      class InstanceNotEqual
-      end
-    end
-  end
-end

data/lib/expressir/model/operators/integer_division.rb

@@ -1,8 +0,0 @@
-module Expressir
-  module Model
-    module Operators
-      class IntegerDivision
-      end
-    end
-  end
-end

data/lib/expressir/model/operators/less_than.rb

@@ -1,8 +0,0 @@
-module Expressir
-  module Model
-    module Operators
-      class LessThan
-      end
-    end
-  end
-end

data/lib/expressir/model/operators/less_than_or_equal.rb

@@ -1,8 +0,0 @@
-module Expressir
-  module Model
-    module Operators
-      class LessThanOrEqual
-      end
-    end
-  end
-end

data/lib/expressir/model/operators/like.rb

@@ -1,8 +0,0 @@
-module Expressir
-  module Model
-    module Operators
-      class Like
-      end
-    end
-  end
-end

data/lib/expressir/model/operators/modulo.rb

@@ -1,8 +0,0 @@
-module Expressir
-  module Model
-    module Operators
-      class Modulo
-      end
-    end
-  end
-end

data/lib/expressir/model/operators/multiplication.rb

@@ -1,8 +0,0 @@
-module Expressir
-  module Model
-    module Operators
-      class Multiplication
-      end
-    end
-  end
-end

data/lib/expressir/model/operators/not.rb

@@ -1,8 +0,0 @@
-module Expressir
-  module Model
-    module Operators
-      class Not
-      end
-    end
-  end
-end

data/lib/expressir/model/operators/not_equal.rb

@@ -1,8 +0,0 @@
-module Expressir
-  module Model
-    module Operators
-      class NotEqual
-      end
-    end
-  end
-end

data/lib/expressir/model/operators/oneof.rb

@@ -1,8 +0,0 @@
-module Expressir
-  module Model
-    module Operators
-      class Oneof
-      end
-    end
-  end
-end

data/lib/expressir/model/operators/or.rb

@@ -1,8 +0,0 @@
-module Expressir
-  module Model
-    module Operators
-      class Or
-      end
-    end
-  end
-end

data/lib/expressir/model/operators/real_division.rb

@@ -1,8 +0,0 @@
-module Expressir
-  module Model
-    module Operators
-      class RealDivision
-      end
-    end
-  end
-end

data/lib/expressir/model/operators/subtraction.rb

@@ -1,8 +0,0 @@
-module Expressir
-  module Model
-    module Operators
-      class Subtraction
-      end
-    end
-  end
-end

data/lib/expressir/model/operators/unary_minus.rb

@@ -1,8 +0,0 @@
-module Expressir
-  module Model
-    module Operators
-      class UnaryMinus
-      end
-    end
-  end
-end

data/lib/expressir/model/operators/unary_plus.rb

@@ -1,8 +0,0 @@
-module Expressir
-  module Model
-    module Operators
-      class UnaryPlus
-      end
-    end
-  end
-end

data/lib/expressir/model/operators/xor.rb

@@ -1,8 +0,0 @@
-module Expressir
-  module Model
-    module Operators
-      class Xor
-      end
-    end
-  end
-end

data/lib/expressir/model/use.rb

@@ -1,13 +0,0 @@
-module Expressir
-  module Model
-    class Use
-      attr_accessor :schema
-      attr_accessor :items
-
-      def initialize(options = {})
-        @schema = options[:schema]
-        @items = options[:items]
-      end
-    end
-  end
-end

data/spec/expressir/express_exp/syntax_spec.rb

@@ -1,2640 +0,0 @@
-require "spec_helper"
-require_relative "../../../lib/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")
-
-      interfaces = schema.interfaces
-      constants = schema.constants
-      types = schema.types
-      entities = schema.entities
-      subtype_constraints = schema.subtype_constraints
-      functions = schema.functions
-      procedures = schema.procedures
-      rules = schema.rules
-
-      # intefaces
-      interfaces.find{|x| x.schema.id == "useInterface"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Use)
-      end
-
-      interfaces.find{|x| x.schema.id == "useItemInterface"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Use)
-        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
-
-      interfaces.find{|x| x.schema.id == "useItemRenameInterface"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Use)
-        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::RenamedRef)
-        expect(x.items[0].ref).to be_instance_of(Expressir::Model::Ref)
-        expect(x.items[0].ref.id).to eq("test")
-        expect(x.items[0].id).to eq("test2")
-      end
-
-      interfaces.find{|x| x.schema.id == "referenceInterface"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Reference)
-      end
-
-      interfaces.find{|x| x.schema.id == "referenceItemInterface"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Reference)
-        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
-
-      interfaces.find{|x| x.schema.id == "referenceItemRenameInterface"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Reference)
-        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::RenamedRef)
-        expect(x.items[0].ref).to be_instance_of(Expressir::Model::Ref)
-        expect(x.items[0].ref.id).to eq("test")
-        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")
-      end
-
-      constants.find{|x| x.id == "integerExpression"}.expression.tap do |x|
-        expect(x).to eq(999)
-      end
-
-      constants.find{|x| x.id == "logicalTrueExpression"}.expression.tap do |x|
-        expect(x).to eq(true)
-      end
-      
-      constants.find{|x| x.id == "logicalFalseExpression"}.expression.tap do |x|
-        expect(x).to eq(false)
-      end
-
-      constants.find{|x| x.id == "logicalUnknownExpression"}.expression.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Expressions::Unknown)
-      end
-
-      constants.find{|x| x.id == "realExpression"}.expression.tap do |x|
-        expect(x).to eq(999.999)
-      end
-
-      constants.find{|x| x.id == "stringSimpleExpression"}.expression.tap do |x|
-        expect(x).to eq("xxx")
-      end
-
-      constants.find{|x| x.id == "stringEncodedExpression"}.expression.tap do |x|
-        expect(x).to eq("xxx")
-      end
-
-      # constants
-      constants.find{|x| x.id == "constEExpression"}.expression.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Ref)
-        expect(x.id).to eq("CONST_E")
-      end
-
-      constants.find{|x| x.id == "indeterminateExpression"}.expression.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Ref)
-        expect(x.id).to eq("?")
-      end
-
-      constants.find{|x| x.id == "piExpression"}.expression.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Ref)
-        expect(x.id).to eq("PI")
-      end
-
-      constants.find{|x| x.id == "selfExpression"}.expression.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Ref)
-        expect(x.id).to eq("SELF")
-      end
-
-      # functions
-      constants.find{|x| x.id == "absExpression"}.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("ABS")
-        expect(x.parameters).to be_instance_of(Array)
-        expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-        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::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)
-      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)
-        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::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)
-      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)
-        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::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)
-      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)
-        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::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)
-      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[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)
-      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)
-        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::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)
-      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)
-        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::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)
-      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[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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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)
-      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[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)
-      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)
-        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::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)
-      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[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)
-      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)
-        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::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)
-      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)
-        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)
-      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[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)
-      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")
-      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)
-      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)
-      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)
-      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)
-      end
-
-      # enumeration references
-      constants.find{|x| x.id == "enumerationReferenceExpression"}.expression.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Ref)
-        expect(x.id).to eq("test")
-      end
-
-      constants.find{|x| x.id == "attributeEnumerationReferenceExpression"}.expression.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
-        expect(x.ref).to be_instance_of(Expressir::Model::Ref)
-        expect(x.ref.id).to eq("test")
-        expect(x.qualifiers).to be_instance_of(Array)
-        expect(x.qualifiers.count).to eq(1)
-        expect(x.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::AttributeQualifier)
-        expect(x.qualifiers[0].attribute).to be_instance_of(Expressir::Model::Ref)
-        expect(x.qualifiers[0].attribute.id).to eq("test")
-      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.operator1).to be_instance_of(Expressir::Model::Operators::LessThan)
-        expect(x.item).to eq(5)
-        expect(x.operator2).to be_instance_of(Expressir::Model::Operators::LessThan)
-        expect(x.high).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.operator1).to be_instance_of(Expressir::Model::Operators::LessThanOrEqual)
-        expect(x.item).to eq(5)
-        expect(x.operator2).to be_instance_of(Expressir::Model::Operators::LessThan)
-        expect(x.high).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.operator1).to be_instance_of(Expressir::Model::Operators::LessThan)
-        expect(x.item).to eq(5)
-        expect(x.operator2).to be_instance_of(Expressir::Model::Operators::LessThanOrEqual)
-        expect(x.high).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.operator1).to be_instance_of(Expressir::Model::Operators::LessThanOrEqual)
-        expect(x.item).to eq(5)
-        expect(x.operator2).to be_instance_of(Expressir::Model::Operators::LessThanOrEqual)
-        expect(x.high).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)
-        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::Ref)
-        expect(x.operands[0].id).to eq("test")
-        expect(x.operands[1]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.operands[1].id).to eq("test")
-      end
-
-      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)
-      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")
-      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)
-      end
-
-      # types
-      types.find{|x| x.id == "integerType"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Type)
-        expect(x.type).to be_instance_of(Expressir::Model::Types::Integer)
-      end
-
-      types.find{|x| x.id == "integerWhereType"}.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].expression).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)
-      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)
-      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.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)
-      end
-
-      types.find{|x| x.id == "integerType"}.type.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Types::Integer)
-      end
-
-      types.find{|x| x.id == "logicalType"}.type.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Types::Logical)
-      end
-
-      types.find{|x| x.id == "numberType"}.type.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Types::Number)
-      end
-
-      types.find{|x| x.id == "realType"}.type.tap do |x|
-        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)
-      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)
-      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.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.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.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.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.optional).to eq(true)
-        expect(x.unique).to eq(true)
-        expect(x.base_type).to be_instance_of(Expressir::Model::Types::String)
-      end
-
-      types.find{|x| x.id == "bagType"}.type.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Types::Bag)
-        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.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.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)
-        expect(x.unique).to eq(true)
-        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.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|
-        expect(x).to be_instance_of(Expressir::Model::Types::Set)
-        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.base_type).to be_instance_of(Expressir::Model::Types::String)
-      end
-
-      # constructed types
-      types.find{|x| x.id == "selectType"}.type.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Types::Select)
-      end
-
-      types.find{|x| x.id == "selectExtensibleType"}.type.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Types::Select)
-        expect(x.extensible).to eq(true)
-      end
-
-      types.find{|x| x.id == "selectExtensibleGenericEntityType"}.type.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Types::Select)
-        expect(x.extensible).to eq(true)
-        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")
-      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)
-        expect(x.extension_type.id).to eq("selectType")
-      end
-
-      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")
-      end
-
-      types.find{|x| x.id == "enumerationType"}.type.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Types::Enumeration)
-      end
-
-      types.find{|x| x.id == "enumerationExtensibleType"}.type.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Types::Enumeration)
-        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")
-      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)
-        expect(x.extension_type.id).to eq("enumerationType")
-      end
-
-      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")
-      end
-
-      # entities
-      entities.find{|x| x.id == "emptyEntity"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Entity)
-      end
-
-      entities.find{|x| x.id == "abstractEntity"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Entity)
-        expect(x.abstract).to eq(true)
-      end
-
-      entities.find{|x| x.id == "abstractSupertypeEntity"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Entity)
-        expect(x.abstract_supertype).to eq(true)
-      end
-
-      entities.find{|x| x.id == "abstractSupertypeConstraintEntity"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Entity)
-        expect(x.abstract_supertype).to eq(true)
-        expect(x.subtype_expression).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.id).to eq("emptyEntity")
-      end
-
-      entities.find{|x| x.id == "supertypeConstraintEntity"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Entity)
-        expect(x.subtype_expression).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.id).to eq("emptyEntity")
-      end
-
-      entities.find{|x| x.id == "subtypeEntity"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Entity)
-        expect(x.supertypes).to be_instance_of(Array)
-        expect(x.supertypes.count).to eq(1)
-        expect(x.supertypes[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.supertypes[0].id).to eq("emptyEntity")
-      end
-
-      entities.find{|x| x.id == "supertypeConstraintSubtypeEntity"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Entity)
-        expect(x.subtype_expression).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.id).to eq("emptyEntity")
-        expect(x.supertypes).to be_instance_of(Array)
-        expect(x.supertypes.count).to eq(1)
-        expect(x.supertypes[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.supertypes[0].id).to eq("emptyEntity")
-      end
-
-      entities.find{|x| x.id == "explicitAttributeEntity"}.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("test")
-        expect(x.explicit[0].type).to be_instance_of(Expressir::Model::Types::Boolean)
-      end
-
-      entities.find{|x| x.id == "explicitAttributeOptionalEntity"}.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("test")
-        expect(x.explicit[0].optional).to eq(true)
-        expect(x.explicit[0].type).to be_instance_of(Expressir::Model::Types::Boolean)
-      end
-
-      entities.find{|x| x.id == "explicitAttributeMultipleEntity"}.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(2)
-        expect(x.explicit[0]).to be_instance_of(Expressir::Model::Explicit)
-        expect(x.explicit[0].id).to eq("test")
-        expect(x.explicit[0].type).to be_instance_of(Expressir::Model::Types::Boolean)
-        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 == "explicitAttributeMultipleShorthandEntity"}.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(2)
-        expect(x.explicit[0]).to be_instance_of(Expressir::Model::Explicit)
-        expect(x.explicit[0].id).to eq("test")
-        expect(x.explicit[0].type).to be_instance_of(Expressir::Model::Types::Boolean)
-        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|
-        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].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)
-      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)
-        expect(x.inverse[0].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 == "inverseAttributeEntityEntity"}.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("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::Expressions::QualifiedRef)
-        expect(x.inverse[0].attribute.ref).to be_instance_of(Expressir::Model::Ref)
-        expect(x.inverse[0].attribute.ref.id).to eq("explicitAttributeEntity")
-        expect(x.inverse[0].attribute.qualifiers).to be_instance_of(Array)
-        expect(x.inverse[0].attribute.qualifiers.count).to eq(1)
-        expect(x.inverse[0].attribute.qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::AttributeQualifier)
-        expect(x.inverse[0].attribute.qualifiers[0].attribute).to be_instance_of(Expressir::Model::Ref)
-        expect(x.inverse[0].attribute.qualifiers[0].attribute.id).to eq("test")
-      end
-
-      entities.find{|x| x.id == "inverseAttributeSetEntity"}.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("test")
-        expect(x.inverse[0].type).to be_instance_of(Expressir::Model::Types::Set)
-        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 == "inverseAttributeSetBoundEntity"}.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("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.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 == "inverseAttributeBagEntity"}.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("test")
-        expect(x.inverse[0].type).to be_instance_of(Expressir::Model::Types::Bag)
-        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 == "inverseAttributeBagBoundEntity"}.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("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.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 == "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)
-        expect(x.unique[0].attributes).to be_instance_of(Array)
-        expect(x.unique[0].attributes.count).to eq(1)
-        expect(x.unique[0].attributes[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.unique[0].attributes[0].id).to eq("test")
-      end
-
-      entities.find{|x| x.id == "uniqueLabelEntity"}.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)
-        expect(x.unique[0].id).to eq("UR1")
-        expect(x.unique[0].attributes).to be_instance_of(Array)
-        expect(x.unique[0].attributes.count).to eq(1)
-        expect(x.unique[0].attributes[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.unique[0].attributes[0].id).to eq("test")
-      end
-
-      entities.find{|x| x.id == "uniqueQualifiedEntity"}.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)
-        expect(x.unique[0].attributes).to be_instance_of(Array)
-        expect(x.unique[0].attributes.count).to eq(1)
-        expect(x.unique[0].attributes[0]).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
-        expect(x.unique[0].attributes[0].ref).to be_instance_of(Expressir::Model::Ref)
-        expect(x.unique[0].attributes[0].ref.id).to eq("SELF")
-        expect(x.unique[0].attributes[0].qualifiers).to be_instance_of(Array)
-        expect(x.unique[0].attributes[0].qualifiers.count).to eq(2)
-        expect(x.unique[0].attributes[0].qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::GroupQualifier)
-        expect(x.unique[0].attributes[0].qualifiers[0].entity).to be_instance_of(Expressir::Model::Ref)
-        expect(x.unique[0].attributes[0].qualifiers[0].entity.id).to eq("explicitAttributeEntity")
-        expect(x.unique[0].attributes[0].qualifiers[1]).to be_instance_of(Expressir::Model::Expressions::AttributeQualifier)
-        expect(x.unique[0].attributes[0].qualifiers[1].attribute).to be_instance_of(Expressir::Model::Ref)
-        expect(x.unique[0].attributes[0].qualifiers[1].attribute.id).to eq("test")
-      end
-
-      entities.find{|x| x.id == "uniqueLabelEntity"}.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)
-        expect(x.unique[0].id).to eq("UR1")
-        expect(x.unique[0].attributes).to be_instance_of(Array)
-        expect(x.unique[0].attributes.count).to eq(1)
-        expect(x.unique[0].attributes[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.unique[0].attributes[0].id).to eq("test")
-      end
-
-      entities.find{|x| x.id == "uniqueLabelQualifiedEntity"}.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)
-        expect(x.unique[0].id).to eq("UR1")
-        expect(x.unique[0].attributes).to be_instance_of(Array)
-        expect(x.unique[0].attributes.count).to eq(1)
-        expect(x.unique[0].attributes[0]).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
-        expect(x.unique[0].attributes[0].ref).to be_instance_of(Expressir::Model::Ref)
-        expect(x.unique[0].attributes[0].ref.id).to eq("SELF")
-        expect(x.unique[0].attributes[0].qualifiers).to be_instance_of(Array)
-        expect(x.unique[0].attributes[0].qualifiers.count).to eq(2)
-        expect(x.unique[0].attributes[0].qualifiers[0]).to be_instance_of(Expressir::Model::Expressions::GroupQualifier)
-        expect(x.unique[0].attributes[0].qualifiers[0].entity).to be_instance_of(Expressir::Model::Ref)
-        expect(x.unique[0].attributes[0].qualifiers[0].entity.id).to eq("explicitAttributeEntity")
-        expect(x.unique[0].attributes[0].qualifiers[1]).to be_instance_of(Expressir::Model::Expressions::AttributeQualifier)
-        expect(x.unique[0].attributes[0].qualifiers[1].attribute).to be_instance_of(Expressir::Model::Ref)
-        expect(x.unique[0].attributes[0].qualifiers[1].attribute.id).to eq("test")
-      end
-
-      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)
-      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)
-      end
-
-      # subtype constraints
-      subtype_constraints.find{|x| x.id == "emptySubtypeConstraint"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::SubtypeConstraint)
-        expect(x.applies_to).to be_instance_of(Expressir::Model::Ref)
-        expect(x.applies_to.id).to eq("emptyEntity")
-      end
-
-      subtype_constraints.find{|x| x.id == "abstractSupertypeSubtypeConstraint"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::SubtypeConstraint)
-        expect(x.applies_to).to be_instance_of(Expressir::Model::Ref)
-        expect(x.applies_to.id).to eq("emptyEntity")
-        expect(x.abstract_supertype).to eq(true)
-      end
-
-      subtype_constraints.find{|x| x.id == "totalOverSubtypeConstraint"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::SubtypeConstraint)
-        expect(x.applies_to).to be_instance_of(Expressir::Model::Ref)
-        expect(x.applies_to.id).to eq("emptyEntity")
-        expect(x.total_over).to be_instance_of(Array)
-        expect(x.total_over.count).to eq(1)
-        expect(x.total_over[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.total_over[0].id).to eq("a")
-      end
-
-      subtype_constraints.find{|x| x.id == "supertypeExpressionSubtypeConstraint"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::SubtypeConstraint)
-        expect(x.applies_to).to be_instance_of(Expressir::Model::Ref)
-        expect(x.applies_to.id).to eq("emptyEntity")
-        expect(x.subtype_expression).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.id).to eq("a")
-      end
-
-      subtype_constraints.find{|x| x.id == "supertypeExpressionAndorSubtypeConstraint"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::SubtypeConstraint)
-        expect(x.applies_to).to be_instance_of(Expressir::Model::Ref)
-        expect(x.applies_to.id).to eq("emptyEntity")
-        expect(x.subtype_expression).to be_instance_of(Expressir::Model::Expressions::Expression)
-        expect(x.subtype_expression.operator).to be_instance_of(Expressir::Model::Operators::Andor)
-        expect(x.subtype_expression.operands).to be_instance_of(Array)
-        expect(x.subtype_expression.operands.count).to eq(2)
-        expect(x.subtype_expression.operands[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[0].id).to eq("a")
-        expect(x.subtype_expression.operands[1]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[1].id).to eq("b")
-      end
-
-      subtype_constraints.find{|x| x.id == "supertypeExpressionAndSubtypeConstraint"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::SubtypeConstraint)
-        expect(x.applies_to).to be_instance_of(Expressir::Model::Ref)
-        expect(x.applies_to.id).to eq("emptyEntity")
-        expect(x.subtype_expression).to be_instance_of(Expressir::Model::Expressions::Expression)
-        expect(x.subtype_expression.operator).to be_instance_of(Expressir::Model::Operators::And)
-        expect(x.subtype_expression.operands).to be_instance_of(Array)
-        expect(x.subtype_expression.operands.count).to eq(2)
-        expect(x.subtype_expression.operands[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[0].id).to eq("a")
-        expect(x.subtype_expression.operands[1]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[1].id).to eq("b")
-      end
-
-      subtype_constraints.find{|x| x.id == "supertypeExpressionAndorAndSubtypeConstraint"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::SubtypeConstraint)
-        expect(x.applies_to).to be_instance_of(Expressir::Model::Ref)
-        expect(x.applies_to.id).to eq("emptyEntity")
-        expect(x.subtype_expression).to be_instance_of(Expressir::Model::Expressions::Expression)
-        expect(x.subtype_expression.operator).to be_instance_of(Expressir::Model::Operators::Andor)
-        expect(x.subtype_expression.operands).to be_instance_of(Array)
-        expect(x.subtype_expression.operands.count).to eq(2)
-        expect(x.subtype_expression.operands[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[0].id).to eq("a")
-        expect(x.subtype_expression.operands[1]).to be_instance_of(Expressir::Model::Expressions::Expression)
-        expect(x.subtype_expression.operands[1].operator).to be_instance_of(Expressir::Model::Operators::And)
-        expect(x.subtype_expression.operands[1].operands).to be_instance_of(Array)
-        expect(x.subtype_expression.operands[1].operands.count).to eq(2)
-        expect(x.subtype_expression.operands[1].operands[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[1].operands[0].id).to eq("b")
-        expect(x.subtype_expression.operands[1].operands[1]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[1].operands[1].id).to eq("c")
-      end
-
-      subtype_constraints.find{|x| x.id == "supertypeExpressionAndAndorSubtypeConstraint"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::SubtypeConstraint)
-        expect(x.applies_to).to be_instance_of(Expressir::Model::Ref)
-        expect(x.applies_to.id).to eq("emptyEntity")
-        expect(x.subtype_expression).to be_instance_of(Expressir::Model::Expressions::Expression)
-        expect(x.subtype_expression.operator).to be_instance_of(Expressir::Model::Operators::Andor)
-        expect(x.subtype_expression.operands).to be_instance_of(Array)
-        expect(x.subtype_expression.operands.count).to eq(2)
-        expect(x.subtype_expression.operands[0]).to be_instance_of(Expressir::Model::Expressions::Expression)
-        expect(x.subtype_expression.operands[0].operator).to be_instance_of(Expressir::Model::Operators::And)
-        expect(x.subtype_expression.operands[0].operands).to be_instance_of(Array)
-        expect(x.subtype_expression.operands[0].operands.count).to eq(2)
-        expect(x.subtype_expression.operands[0].operands[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[0].operands[0].id).to eq("a")
-        expect(x.subtype_expression.operands[0].operands[1]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[0].operands[1].id).to eq("b")
-        expect(x.subtype_expression.operands[1]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[1].id).to eq("c")
-      end
-
-      subtype_constraints.find{|x| x.id == "supertypeExpressionParenthesisAndorAndSubtypeConstraint"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::SubtypeConstraint)
-        expect(x.applies_to).to be_instance_of(Expressir::Model::Ref)
-        expect(x.applies_to.id).to eq("emptyEntity")
-        expect(x.subtype_expression).to be_instance_of(Expressir::Model::Expressions::Expression)
-        expect(x.subtype_expression.operator).to be_instance_of(Expressir::Model::Operators::And)
-        expect(x.subtype_expression.operands).to be_instance_of(Array)
-        expect(x.subtype_expression.operands.count).to eq(2)
-        expect(x.subtype_expression.operands[0]).to be_instance_of(Expressir::Model::Expressions::Expression)
-        expect(x.subtype_expression.operands[0].operator).to be_instance_of(Expressir::Model::Operators::Andor)
-        expect(x.subtype_expression.operands[0].operands).to be_instance_of(Array)
-        expect(x.subtype_expression.operands[0].operands.count).to eq(2)
-        expect(x.subtype_expression.operands[0].operands[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[0].operands[0].id).to eq("a")
-        expect(x.subtype_expression.operands[0].operands[1]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[0].operands[1].id).to eq("b")
-        expect(x.subtype_expression.operands[1]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[1].id).to eq("c")
-      end
-
-      subtype_constraints.find{|x| x.id == "supertypeExpressionAndParenthesisAndorSubtypeConstraint"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::SubtypeConstraint)
-        expect(x.applies_to).to be_instance_of(Expressir::Model::Ref)
-        expect(x.applies_to.id).to eq("emptyEntity")
-        expect(x.subtype_expression).to be_instance_of(Expressir::Model::Expressions::Expression)
-        expect(x.subtype_expression.operator).to be_instance_of(Expressir::Model::Operators::And)
-        expect(x.subtype_expression.operands).to be_instance_of(Array)
-        expect(x.subtype_expression.operands.count).to eq(2)
-        expect(x.subtype_expression.operands[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[0].id).to eq("a")
-        expect(x.subtype_expression.operands[1]).to be_instance_of(Expressir::Model::Expressions::Expression)
-        expect(x.subtype_expression.operands[1].operator).to be_instance_of(Expressir::Model::Operators::Andor)
-        expect(x.subtype_expression.operands[1].operands).to be_instance_of(Array)
-        expect(x.subtype_expression.operands[1].operands.count).to eq(2)
-        expect(x.subtype_expression.operands[1].operands[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[1].operands[0].id).to eq("b")
-        expect(x.subtype_expression.operands[1].operands[1]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[1].operands[1].id).to eq("c")
-      end
-
-      subtype_constraints.find{|x| x.id == "supertypeExpressionOneofSubtypeConstraint"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::SubtypeConstraint)
-        expect(x.applies_to).to be_instance_of(Expressir::Model::Ref)
-        expect(x.applies_to.id).to eq("emptyEntity")
-        expect(x.subtype_expression).to be_instance_of(Expressir::Model::Expressions::Expression)
-        expect(x.subtype_expression.operator).to be_instance_of(Expressir::Model::Operators::Oneof)
-        expect(x.subtype_expression.operands).to be_instance_of(Array)
-        expect(x.subtype_expression.operands.count).to eq(2)
-        expect(x.subtype_expression.operands[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[0].id).to eq("a")
-        expect(x.subtype_expression.operands[1]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[1].id).to eq("b")
-      end
-
-      subtype_constraints.find{|x| x.id == "supertypeExpressionAndOneofSubtypeConstraint"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::SubtypeConstraint)
-        expect(x.applies_to).to be_instance_of(Expressir::Model::Ref)
-        expect(x.applies_to.id).to eq("emptyEntity")
-        expect(x.subtype_expression).to be_instance_of(Expressir::Model::Expressions::Expression)
-        expect(x.subtype_expression.operator).to be_instance_of(Expressir::Model::Operators::And)
-        expect(x.subtype_expression.operands).to be_instance_of(Array)
-        expect(x.subtype_expression.operands.count).to eq(2)
-        expect(x.subtype_expression.operands[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[0].id).to eq("a")
-        expect(x.subtype_expression.operands[1]).to be_instance_of(Expressir::Model::Expressions::Expression)
-        expect(x.subtype_expression.operands[1].operator).to be_instance_of(Expressir::Model::Operators::Oneof)
-        expect(x.subtype_expression.operands[1].operands).to be_instance_of(Array)
-        expect(x.subtype_expression.operands[1].operands.count).to eq(2)
-        expect(x.subtype_expression.operands[1].operands[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[1].operands[0].id).to eq("b")
-        expect(x.subtype_expression.operands[1].operands[1]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[1].operands[1].id).to eq("c")
-      end
-
-      subtype_constraints.find{|x| x.id == "supertypeExpressionAndorOneofSubtypeConstraint"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::SubtypeConstraint)
-        expect(x.applies_to).to be_instance_of(Expressir::Model::Ref)
-        expect(x.applies_to.id).to eq("emptyEntity")
-        expect(x.subtype_expression).to be_instance_of(Expressir::Model::Expressions::Expression)
-        expect(x.subtype_expression.operator).to be_instance_of(Expressir::Model::Operators::Andor)
-        expect(x.subtype_expression.operands).to be_instance_of(Array)
-        expect(x.subtype_expression.operands.count).to eq(2)
-        expect(x.subtype_expression.operands[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[0].id).to eq("a")
-        expect(x.subtype_expression.operands[1]).to be_instance_of(Expressir::Model::Expressions::Expression)
-        expect(x.subtype_expression.operands[1].operator).to be_instance_of(Expressir::Model::Operators::Oneof)
-        expect(x.subtype_expression.operands[1].operands).to be_instance_of(Array)
-        expect(x.subtype_expression.operands[1].operands.count).to eq(2)
-        expect(x.subtype_expression.operands[1].operands[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[1].operands[0].id).to eq("b")
-        expect(x.subtype_expression.operands[1].operands[1]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[1].operands[1].id).to eq("c")
-      end
-
-      subtype_constraints.find{|x| x.id == "supertypeExpressionOneofAndSubtypeConstraint"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::SubtypeConstraint)
-        expect(x.applies_to).to be_instance_of(Expressir::Model::Ref)
-        expect(x.applies_to.id).to eq("emptyEntity")
-        expect(x.subtype_expression).to be_instance_of(Expressir::Model::Expressions::Expression)
-        expect(x.subtype_expression.operator).to be_instance_of(Expressir::Model::Operators::And)
-        expect(x.subtype_expression.operands).to be_instance_of(Array)
-        expect(x.subtype_expression.operands.count).to eq(2)
-        expect(x.subtype_expression.operands[0]).to be_instance_of(Expressir::Model::Expressions::Expression)
-        expect(x.subtype_expression.operands[0].operator).to be_instance_of(Expressir::Model::Operators::Oneof)
-        expect(x.subtype_expression.operands[0].operands).to be_instance_of(Array)
-        expect(x.subtype_expression.operands[0].operands.count).to eq(2)
-        expect(x.subtype_expression.operands[0].operands[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[0].operands[0].id).to eq("a")
-        expect(x.subtype_expression.operands[0].operands[1]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[0].operands[1].id).to eq("b")
-        expect(x.subtype_expression.operands[1]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[1].id).to eq("c")
-      end
-
-      subtype_constraints.find{|x| x.id == "supertypeExpressionOneofAndorSubtypeConstraint"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::SubtypeConstraint)
-        expect(x.applies_to).to be_instance_of(Expressir::Model::Ref)
-        expect(x.applies_to.id).to eq("emptyEntity")
-        expect(x.subtype_expression).to be_instance_of(Expressir::Model::Expressions::Expression)
-        expect(x.subtype_expression.operator).to be_instance_of(Expressir::Model::Operators::Andor)
-        expect(x.subtype_expression.operands).to be_instance_of(Array)
-        expect(x.subtype_expression.operands.count).to eq(2)
-        expect(x.subtype_expression.operands[0]).to be_instance_of(Expressir::Model::Expressions::Expression)
-        expect(x.subtype_expression.operands[0].operator).to be_instance_of(Expressir::Model::Operators::Oneof)
-        expect(x.subtype_expression.operands[0].operands).to be_instance_of(Array)
-        expect(x.subtype_expression.operands[0].operands.count).to eq(2)
-        expect(x.subtype_expression.operands[0].operands[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[0].operands[0].id).to eq("a")
-        expect(x.subtype_expression.operands[0].operands[1]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[0].operands[1].id).to eq("b")
-        expect(x.subtype_expression.operands[1]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[1].id).to eq("c")
-      end
-
-      subtype_constraints.find{|x| x.id == "supertypeExpressionOneofAndOneofSubtypeConstraint"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::SubtypeConstraint)
-        expect(x.applies_to).to be_instance_of(Expressir::Model::Ref)
-        expect(x.applies_to.id).to eq("emptyEntity")
-        expect(x.subtype_expression).to be_instance_of(Expressir::Model::Expressions::Expression)
-        expect(x.subtype_expression.operator).to be_instance_of(Expressir::Model::Operators::And)
-        expect(x.subtype_expression.operands).to be_instance_of(Array)
-        expect(x.subtype_expression.operands.count).to eq(2)
-        expect(x.subtype_expression.operands[0]).to be_instance_of(Expressir::Model::Expressions::Expression)
-        expect(x.subtype_expression.operands[0].operator).to be_instance_of(Expressir::Model::Operators::Oneof)
-        expect(x.subtype_expression.operands[0].operands).to be_instance_of(Array)
-        expect(x.subtype_expression.operands[0].operands.count).to eq(2)
-        expect(x.subtype_expression.operands[0].operands[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[0].operands[0].id).to eq("a")
-        expect(x.subtype_expression.operands[0].operands[1]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[0].operands[1].id).to eq("b")
-        expect(x.subtype_expression.operands[1]).to be_instance_of(Expressir::Model::Expressions::Expression)
-        expect(x.subtype_expression.operands[1].operator).to be_instance_of(Expressir::Model::Operators::Oneof)
-        expect(x.subtype_expression.operands[1].operands).to be_instance_of(Array)
-        expect(x.subtype_expression.operands[1].operands.count).to eq(2)
-        expect(x.subtype_expression.operands[1].operands[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[1].operands[0].id).to eq("c")
-        expect(x.subtype_expression.operands[1].operands[1]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[1].operands[1].id).to eq("d")
-      end
-
-      subtype_constraints.find{|x| x.id == "supertypeExpressionOneofAndorOneofSubtypeConstraint"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::SubtypeConstraint)
-        expect(x.applies_to).to be_instance_of(Expressir::Model::Ref)
-        expect(x.applies_to.id).to eq("emptyEntity")
-        expect(x.subtype_expression).to be_instance_of(Expressir::Model::Expressions::Expression)
-        expect(x.subtype_expression.operator).to be_instance_of(Expressir::Model::Operators::Andor)
-        expect(x.subtype_expression.operands).to be_instance_of(Array)
-        expect(x.subtype_expression.operands.count).to eq(2)
-        expect(x.subtype_expression.operands[0]).to be_instance_of(Expressir::Model::Expressions::Expression)
-        expect(x.subtype_expression.operands[0].operator).to be_instance_of(Expressir::Model::Operators::Oneof)
-        expect(x.subtype_expression.operands[0].operands).to be_instance_of(Array)
-        expect(x.subtype_expression.operands[0].operands.count).to eq(2)
-        expect(x.subtype_expression.operands[0].operands[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[0].operands[0].id).to eq("a")
-        expect(x.subtype_expression.operands[0].operands[1]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[0].operands[1].id).to eq("b")
-        expect(x.subtype_expression.operands[1]).to be_instance_of(Expressir::Model::Expressions::Expression)
-        expect(x.subtype_expression.operands[1].operator).to be_instance_of(Expressir::Model::Operators::Oneof)
-        expect(x.subtype_expression.operands[1].operands).to be_instance_of(Array)
-        expect(x.subtype_expression.operands[1].operands.count).to eq(2)
-        expect(x.subtype_expression.operands[1].operands[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[1].operands[0].id).to eq("c")
-        expect(x.subtype_expression.operands[1].operands[1]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.subtype_expression.operands[1].operands[1].id).to eq("d")
-      end
-
-      # functions
-      functions.find{|x| x.id == "emptyFunction"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Function)
-        expect(x.return_type).to be_instance_of(Expressir::Model::Types::Boolean)
-        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 == "parameterFunction"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Function)
-        expect(x.parameters).to be_instance_of(Array)
-        expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Parameter)
-        expect(x.parameters[0].id).to eq("test")
-        expect(x.parameters[0].type).to be_instance_of(Expressir::Model::Types::Boolean)
-        expect(x.return_type).to be_instance_of(Expressir::Model::Types::Boolean)
-        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 == "multipleParameterFunction"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Function)
-        expect(x.parameters).to be_instance_of(Array)
-        expect(x.parameters.count).to eq(2)
-        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Parameter)
-        expect(x.parameters[0].id).to eq("test")
-        expect(x.parameters[0].type).to be_instance_of(Expressir::Model::Types::Boolean)
-        expect(x.parameters[1]).to be_instance_of(Expressir::Model::Parameter)
-        expect(x.parameters[1].id).to eq("test2")
-        expect(x.parameters[1].type).to be_instance_of(Expressir::Model::Types::Boolean)
-        expect(x.return_type).to be_instance_of(Expressir::Model::Types::Boolean)
-        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 == "multipleShorthandParameterFunction"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Function)
-        expect(x.parameters).to be_instance_of(Array)
-        expect(x.parameters.count).to eq(2)
-        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Parameter)
-        expect(x.parameters[0].id).to eq("test")
-        expect(x.parameters[0].type).to be_instance_of(Expressir::Model::Types::Boolean)
-        expect(x.parameters[1]).to be_instance_of(Expressir::Model::Parameter)
-        expect(x.parameters[1].id).to eq("test2")
-        expect(x.parameters[1].type).to be_instance_of(Expressir::Model::Types::Boolean)
-        expect(x.return_type).to be_instance_of(Expressir::Model::Types::Boolean)
-        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 == "typeFunction"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Function)
-        expect(x.return_type).to be_instance_of(Expressir::Model::Types::Boolean)
-        expect(x.declarations).to be_instance_of(Array)
-        expect(x.declarations.count).to eq(1)
-        expect(x.declarations[0]).to be_instance_of(Expressir::Model::Type)
-        expect(x.declarations[0].id).to eq("integerType")
-        expect(x.declarations[0].type).to be_instance_of(Expressir::Model::Types::Integer)
-        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 == "constantFunction"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Function)
-        expect(x.return_type).to be_instance_of(Expressir::Model::Types::Boolean)
-        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.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 == "multipleConstantFunction"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Function)
-        expect(x.return_type).to be_instance_of(Expressir::Model::Types::Boolean)
-        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[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.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 == "localFunction"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Function)
-        expect(x.return_type).to be_instance_of(Expressir::Model::Types::Boolean)
-        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.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 == "multipleLocalFunction"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Function)
-        expect(x.return_type).to be_instance_of(Expressir::Model::Types::Boolean)
-        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[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.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 == "multipleShorthandLocalFunction"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Function)
-        expect(x.return_type).to be_instance_of(Expressir::Model::Types::Boolean)
-        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[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.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 == "localExpressionFunction"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Function)
-        expect(x.return_type).to be_instance_of(Expressir::Model::Types::Boolean)
-        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.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 == "multipleLocalExpressionFunction"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Function)
-        expect(x.return_type).to be_instance_of(Expressir::Model::Types::Boolean)
-        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[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.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 == "multipleShorthandLocalExpressionFunction"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Function)
-        expect(x.return_type).to be_instance_of(Expressir::Model::Types::Boolean)
-        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[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.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
-
-      # procedures
-      procedures.find{|x| x.id == "emptyProcedure"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Procedure)
-      end
-
-      procedures.find{|x| x.id == "parameterProcedure"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Procedure)
-        expect(x.parameters).to be_instance_of(Array)
-        expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Parameter)
-        expect(x.parameters[0].id).to eq("test")
-        expect(x.parameters[0].type).to be_instance_of(Expressir::Model::Types::Boolean)
-        expect(x.parameters[0].var).not_to eq(true)
-      end
-
-      procedures.find{|x| x.id == "multipleParameterProcedure"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Procedure)
-        expect(x.parameters).to be_instance_of(Array)
-        expect(x.parameters.count).to eq(2)
-        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Parameter)
-        expect(x.parameters[0].id).to eq("test")
-        expect(x.parameters[0].type).to be_instance_of(Expressir::Model::Types::Boolean)
-        expect(x.parameters[0].var).not_to eq(true)
-        expect(x.parameters[1]).to be_instance_of(Expressir::Model::Parameter)
-        expect(x.parameters[1].id).to eq("test2")
-        expect(x.parameters[1].type).to be_instance_of(Expressir::Model::Types::Boolean)
-        expect(x.parameters[1].var).not_to eq(true)
-      end
-
-      procedures.find{|x| x.id == "multipleShorthandParameterProcedure"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Procedure)
-        expect(x.parameters).to be_instance_of(Array)
-        expect(x.parameters.count).to eq(2)
-        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Parameter)
-        expect(x.parameters[0].id).to eq("test")
-        expect(x.parameters[0].type).to be_instance_of(Expressir::Model::Types::Boolean)
-        expect(x.parameters[0].var).not_to eq(true)
-        expect(x.parameters[1]).to be_instance_of(Expressir::Model::Parameter)
-        expect(x.parameters[1].id).to eq("test2")
-        expect(x.parameters[1].type).to be_instance_of(Expressir::Model::Types::Boolean)
-        expect(x.parameters[1].var).not_to eq(true)
-      end
-
-      procedures.find{|x| x.id == "variableParameterProcedure"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Procedure)
-        expect(x.parameters).to be_instance_of(Array)
-        expect(x.parameters.count).to eq(1)
-        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Parameter)
-        expect(x.parameters[0].id).to eq("test")
-        expect(x.parameters[0].type).to be_instance_of(Expressir::Model::Types::Boolean)
-        expect(x.parameters[0].var).to eq(true)
-      end
-
-      procedures.find{|x| x.id == "multipleVariableParameterProcedure"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Procedure)
-        expect(x.parameters).to be_instance_of(Array)
-        expect(x.parameters.count).to eq(2)
-        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Parameter)
-        expect(x.parameters[0].id).to eq("test")
-        expect(x.parameters[0].type).to be_instance_of(Expressir::Model::Types::Boolean)
-        expect(x.parameters[0].var).to eq(true)
-        expect(x.parameters[1]).to be_instance_of(Expressir::Model::Parameter)
-        expect(x.parameters[1].id).to eq("test2")
-        expect(x.parameters[1].type).to be_instance_of(Expressir::Model::Types::Boolean)
-        expect(x.parameters[1].var).not_to eq(true)
-      end
-
-      procedures.find{|x| x.id == "multipleVariableParameter2Procedure"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Procedure)
-        expect(x.parameters).to be_instance_of(Array)
-        expect(x.parameters.count).to eq(2)
-        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Parameter)
-        expect(x.parameters[0].id).to eq("test")
-        expect(x.parameters[0].type).to be_instance_of(Expressir::Model::Types::Boolean)
-        expect(x.parameters[0].var).not_to eq(true)
-        expect(x.parameters[1]).to be_instance_of(Expressir::Model::Parameter)
-        expect(x.parameters[1].id).to eq("test2")
-        expect(x.parameters[1].type).to be_instance_of(Expressir::Model::Types::Boolean)
-        expect(x.parameters[1].var).to eq(true)
-      end
-
-      procedures.find{|x| x.id == "multipleShorthandVariableParameterProcedure"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Procedure)
-        expect(x.parameters).to be_instance_of(Array)
-        expect(x.parameters.count).to eq(2)
-        expect(x.parameters[0]).to be_instance_of(Expressir::Model::Parameter)
-        expect(x.parameters[0].id).to eq("test")
-        expect(x.parameters[0].type).to be_instance_of(Expressir::Model::Types::Boolean)
-        expect(x.parameters[0].var).to eq(true)
-        expect(x.parameters[1]).to be_instance_of(Expressir::Model::Parameter)
-        expect(x.parameters[1].id).to eq("test2")
-        expect(x.parameters[1].type).to be_instance_of(Expressir::Model::Types::Boolean)
-        expect(x.parameters[1].var).to eq(true)
-      end
-
-      procedures.find{|x| x.id == "typeProcedure"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Procedure)
-        expect(x.declarations).to be_instance_of(Array)
-        expect(x.declarations.count).to eq(1)
-        expect(x.declarations[0]).to be_instance_of(Expressir::Model::Type)
-        expect(x.declarations[0].id).to eq("integerType")
-        expect(x.declarations[0].type).to be_instance_of(Expressir::Model::Types::Integer)
-      end
-
-      procedures.find{|x| x.id == "constantProcedure"}.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(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")
-      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[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")
-      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)
-        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)
-      end
-
-      procedures.find{|x| x.id == "multipleLocalProcedure"}.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[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)
-      end
-
-      procedures.find{|x| x.id == "multipleShorthandLocalProcedure"}.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[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)
-      end
-
-      procedures.find{|x| x.id == "localExpressionProcedure"}.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(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")
-      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[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")
-      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[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")
-      end
-
-      # rules
-      rules.find{|x| x.id == "emptyRule"}.tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Rule)
-        expect(x.applies_to).to be_instance_of(Array)
-        expect(x.applies_to.count).to eq(1)
-        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)
-      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)
-        expect(x.applies_to.count).to eq(1)
-        expect(x.applies_to[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.applies_to[0].id).to eq("emptyEntity")
-        expect(x.declarations).to be_instance_of(Array)
-        expect(x.declarations.count).to eq(1)
-        expect(x.declarations[0]).to be_instance_of(Expressir::Model::Type)
-        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)
-      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)
-        expect(x.applies_to.count).to eq(1)
-        expect(x.applies_to[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.applies_to[0].id).to eq("emptyEntity")
-        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.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)
-      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)
-        expect(x.applies_to.count).to eq(1)
-        expect(x.applies_to[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.applies_to[0].id).to eq("emptyEntity")
-        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[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.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)
-      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)
-        expect(x.applies_to.count).to eq(1)
-        expect(x.applies_to[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.applies_to[0].id).to eq("emptyEntity")
-        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.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)
-      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)
-        expect(x.applies_to.count).to eq(1)
-        expect(x.applies_to[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.applies_to[0].id).to eq("emptyEntity")
-        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[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.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)
-      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)
-        expect(x.applies_to.count).to eq(1)
-        expect(x.applies_to[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.applies_to[0].id).to eq("emptyEntity")
-        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[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.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)
-      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)
-        expect(x.applies_to.count).to eq(1)
-        expect(x.applies_to[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.applies_to[0].id).to eq("emptyEntity")
-        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.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)
-      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)
-        expect(x.applies_to.count).to eq(1)
-        expect(x.applies_to[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.applies_to[0].id).to eq("emptyEntity")
-        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[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.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)
-      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)
-        expect(x.applies_to.count).to eq(1)
-        expect(x.applies_to[0]).to be_instance_of(Expressir::Model::Ref)
-        expect(x.applies_to[0].id).to eq("emptyEntity")
-        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[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.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)
-      end
-
-      # statements
-      functions.find{|x| x.id == "aliasStatement"}.statements[0].tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Statements::Alias)
-        expect(x.id).to eq("test")
-        expect(x.expression).to be_instance_of(Expressir::Model::Ref)
-        expect(x.expression.id).to eq("test")
-        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 == "aliasAttributeStatement"}.statements[0].tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Statements::Alias)
-        expect(x.id).to eq("test")
-        expect(x.expression).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
-        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::AttributeQualifier)
-        expect(x.expression.qualifiers[0].attribute).to be_instance_of(Expressir::Model::Ref)
-        expect(x.expression.qualifiers[0].attribute.id).to eq("test")
-        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 == "aliasGroupStatement"}.statements[0].tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Statements::Alias)
-        expect(x.id).to eq("test")
-        expect(x.expression).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
-        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::GroupQualifier)
-        expect(x.expression.qualifiers[0].entity).to be_instance_of(Expressir::Model::Ref)
-        expect(x.expression.qualifiers[0].entity.id).to eq("test")
-        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 == "aliasIndexStatement"}.statements[0].tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Statements::Alias)
-        expect(x.id).to eq("test")
-        expect(x.expression).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
-        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.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 == "aliasIndex2Statement"}.statements[0].tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Statements::Alias)
-        expect(x.id).to eq("test")
-        expect(x.expression).to be_instance_of(Expressir::Model::Expressions::QualifiedRef)
-        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.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)
-      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)
-        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::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)
-      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)
-        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::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)
-      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)
-      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)
-      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].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].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].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].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].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].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|
-        expect(x).to be_instance_of(Expressir::Model::Statements::Compound)
-        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 == "escapeStatement"}.statements[0].tap do |x|
-        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.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.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.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.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)
-        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 == "ifElse2Statement"}.statements[0].tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Statements::If)
-        expect(x.condition).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)
-        expect(x.else_statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
-        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.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)
-        expect(x.else_statements.count).to eq(2)
-        expect(x.else_statements[0]).to be_instance_of(Expressir::Model::Statements::Null)
-        expect(x.else_statements[1]).to be_instance_of(Expressir::Model::Statements::Null)
-      end
-
-      functions.find{|x| x.id == "nullStatement"}.statements[0].tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Statements::Null)
-      end
-
-      functions.find{|x| x.id == "procedureCallStatement"}.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")
-      end
-
-      functions.find{|x| x.id == "procedureCallParameterStatement"}.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(1)
-        expect(x.parameters[0]).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)
-      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)
-        expect(x.procedure.id).to eq("INSERT")
-      end
-
-      functions.find{|x| x.id == "procedureCallRemoveStatement"}.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("REMOVE")
-      end
-
-      functions.find{|x| x.id == "repeatStatement"}.statements[0].tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Statements::Repeat)
-        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 == "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.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.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.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.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)
-      end
-
-      functions.find{|x| x.id == "skipStatement"}.statements[0].tap do |x|
-        expect(x).to be_instance_of(Expressir::Model::Statements::Skip)
-      end
-    end
-  end
-
-  def sample_file
-    @sample_file ||= Expressir.root_path.join(
-      "original", "examples", "syntax", "syntax.exp"
-    )
-  end
-end