mbt-gen 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ac020a4fa0dd1933cbc568d8d378919d0136525a7172830add366461a7fbda3
-  data.tar.gz: b3da4c6ef18e9542e9efc96db915537197663a391f43e7102749cdccf6ae7f72
+  metadata.gz: 056ec1e0d6d661c5c4a092e4a7e879f610a7524dfa63fb7faf9779d8fc4bfc6e
+  data.tar.gz: 20f715037f76a5e23dd5407416018ff7c2cbf3c64a616c6fe32117bc0b411a20
 SHA512:
-  metadata.gz: 4d653ef8c58e941b0b5aa513eb67cafbec0b54c3b103e5506cbab5c041c63afff153ad1b469c1486e1775f64834b25d0de4a97ea34ea8d12742d82d8d556d609
-  data.tar.gz: 418fc3e0151700e49d5141add6d38ab3557af788e9b7aa6e97b3c599d487ae1736516fcc623a71b8b4af2102fcf0362cca888d9c49c02eefc19925d165e5d4fc
+  metadata.gz: 7cfca600b07970cc752fa96da6e9dc1052af81024e94c87f581b49632cb414e13d6e71c05dfbb7dc51eab907e3f0ef504ac880994b59cd83347a038c8709fbd5
+  data.tar.gz: 2ba5fa686c5a8894431e714481953ea2c4989de0825e14c526e273ba10e798250003492195b5163a69ebfe53e1cba7d9b243d9f9c5ae82806484b3026a4e793a

data/lib/mbt-gen.rb

@@ -18,9 +18,9 @@ DEFAULT_Z3_PATH = "z3"
 
 CONFIG_FILE = "config.yml"
 OUTPUT_FILE = "result.xml"
-CONTINUATION_FILE = 'continuation.log'
-COMBINATION_LOG = 'combinations.log'
-VARS_LOG = 'vars.log'
+CONTINUATION_FILE = "continuation.log"
+COMBINATION_LOG = "combinations.log"
+VARS_LOG = "vars.log"
 
 OUTPUT_DIR = "result"
 LISTS_DIR = "lists"
@@ -73,6 +73,11 @@ GENERATING MESSAGES FOR ALL COMBINATIONS:
           be restarted later by adding -continue to the command line.
   NOTE: do not expect the number of generated documents to equal the number of combinations as combinations may not have any valid message instances (for instance when they contradict the validation rules).
   NOTE: the result can be found in the directory #{OUTPUT_DIR}
+
+VALIDATING THE MODEL:
+
+  ruby #{$PROGRAM_NAME} -validate <file.xml>
+  - reads in the given XML file and validates it against the model - that is, it checks whether it conforms to the specified XML schema and to the validation rules.
 EOF
 
 class FatalError < RuntimeError
@@ -167,38 +172,100 @@ def enum_constraint_for_expr(expr, values)
   "(or #{values.map{|x| "(= #{expr} #{translate_value_to_SMTLIB(x)})"}.join(" ")})"
 end
 
-def translate_field_def_to_SMTLIB_constraints(progress, solver, fielddef, varname)
+def translate_field_def_to_SMTLIB_constraints(progress, solver, fielddef, xpath)
+  varname = raw_field(xpath)
   if fielddef[:optional] == nil || fielddef[:optional] == false then
     # field is required
-    solver.to_solver(progress, "(assert (! #{varname}-filled :named required-#{varname}))") 
+    assertionID = "required-#{varname}"
+    info = {
+      :assertion_type => :constraint,
+      :xpath => xpath,
+      :constraint_type => :required
+    }
+    solver.associateAssertionIDWith(assertionID, info)
+    solver.to_solver(progress, "(assert (! #{varname}-filled :named #{assertionID}))")
   end
   datatype = fielddef[:datatype]
   case datatype
   when :int
     if fielddef[:min] then
-        solver.to_solver(progress, "(assert (! (=> #{varname}-filled #{min_constraint_for_expr("#{varname}-value", translate_value_to_SMTLIB(fielddef[:min]))}) :named min-#{varname}))") 
+        assertionID = "min-#{varname}"
+        info = {
+          :assertion_type => :constraint,
+          :xpath => xpath,
+          :datatype => :int,
+          :value => fielddef[:min],
+          :constraint_type => :min
+        }
+        solver.associateAssertionIDWith(assertionID, info)
+        solver.to_solver(progress, "(assert (! (=> #{varname}-filled #{min_constraint_for_expr("#{varname}-value", translate_value_to_SMTLIB(fielddef[:min]))}) :named #{assertionID}))") 
     end
     if fielddef[:max] then
-        solver.to_solver(progress, "(assert (! (=> #{varname}-filled #{max_constraint_for_expr("#{varname}-value", translate_value_to_SMTLIB(fielddef[:max]))}) :named max-#{varname}))") 
+        assertionID = "max-#{varname}"
+        info = {
+          :assertion_type => :constraint,
+          :xpath => xpath,
+          :datatype => :int,
+          :value => fielddef[:max],
+          :constraint_type => :max
+        }
+        solver.associateAssertionIDWith(assertionID, info)
+        solver.to_solver(progress, "(assert (! (=> #{varname}-filled #{max_constraint_for_expr("#{varname}-value", translate_value_to_SMTLIB(fielddef[:max]))}) :named #{assertionID}))")
     end
   when :string
     if fielddef[:regex] then
-        solver.to_solver(progress, "(assert (! (=> #{varname}-filled #{regex_constraint_for_expr("#{varname}-value", fielddef[:regex])}) :named regex-#{varname}))") 
+        assertionID = "regex-#{varname}"
+        info = {
+          :assertion_type => :constraint,
+          :xpath => xpath,
+          :datatype => :string,
+          :pattern => fielddef[:regex],
+          :constraint_type => :regex
+        }
+        solver.associateAssertionIDWith(assertionID, info)
+        solver.to_solver(progress, "(assert (! (=> #{varname}-filled #{regex_constraint_for_expr("#{varname}-value", fielddef[:regex])}) :named #{assertionID}))") 
     end 
     # TODO: minLength?
     if fielddef[:maxLength] then
-      solver.to_solver(progress, "(assert (! (=> #{varname}-filled #{maxLength_contraint_for_expr("#{varname}-value", fielddef[:maxLength])}) :named maxLength-#{varname}))") 
+      assertionID = "maxLength-#{varname}"
+        info = {
+          :assertion_type => :constraint,
+          :xpath => xpath,
+          :datatype => :string,
+          :value => fielddef[:maxLength],
+          :constraint_type => :maxLength
+        }
+      solver.associateAssertionIDWith(assertionID, info)
+      solver.to_solver(progress, "(assert (! (=> #{varname}-filled #{maxLength_contraint_for_expr("#{varname}-value", fielddef[:maxLength])}) :named #{assertionID}))") 
     end
     if fielddef[:from_list] then
+      assertionID = "oneOf-#{varname}"
       list_filename = "#{LISTS_DIR}/#{fielddef[:from_list]}"
+      info = {
+        :assertion_type => :constraint,
+        :xpath => xpath,
+        :datatype => :string,
+        :filename => list_filename,
+        :constraint_type => :from_list
+      }
       unless File.exist?(list_filename)
         raise RuntimeError.new("could not find list file #{list_filename}.")
       end
       values = File.read(list_filename).split("\n").map{|v| v.chomp()}
-      solver.to_solver(progress, "(assert (! (=> #{varname}-filled #{oneOf_contraint_for_expr("#{varname}-value", values)}) :named oneOf-#{varname}))") 
+      solver.associateAssertionIDWith(assertionID, info)
+      solver.to_solver(progress, "(assert (! (=> #{varname}-filled #{oneOf_contraint_for_expr("#{varname}-value", values)}) :named #{assertionID}))") 
     end
   when :enum
-    solver.to_solver(progress, "(assert (! (=> #{varname}-filled #{enum_constraint_for_expr("#{varname}-value", fielddef[:values])}) :named enum-#{varname}))") 
+    assertionID = "enum-#{varname}"
+    info = {
+      :assertion_type => :constraint,
+      :xpath => xpath,
+      :datatype => :enum,
+      :values => fielddef[:values],
+      :constraint_type => :values
+    }
+    solver.associateAssertionIDWith(assertionID, info)
+    solver.to_solver(progress, "(assert (! (=> #{varname}-filled #{enum_constraint_for_expr("#{varname}-value", fielddef[:values])}) :named #{assertionID}))") 
   end
 end
 
@@ -290,13 +357,15 @@ def translate_substructure_to_SMTLIB(progress, solver, struct, hash = {})
         if (struct_varname)
           solver.to_solver(progress, "(assert (! (=> (not #{struct_varname}) (not #{filled_var_for_field(xpath)})) :named empty-struct-has-no-fields-for-#{raw_field(xpath)}))") 
         end
-        translate_field_def_to_SMTLIB_constraints(progress, solver, definition, raw_field(xpath))
+        translate_field_def_to_SMTLIB_constraints(progress, solver, definition, xpath)
       elsif definition[:type] == :list then
         display_prefix = ""
         display_prefix = "#{prefix}/" if prefix
         xpath = field.to_s
         xpath = "#{prefix}/#{xpath}" if prefix
+        solver.declare_const(progress, filled_var_for_field(xpath), "Bool", {:xpath => xpath})
         solver.declare_const(progress, size_var_for_list(xpath), "Int", {:xpath => xpath})
+        solver.to_solver(progress, "(assert (! (=> (not #{filled_var_for_field(xpath)}) (= #{size_var_for_list(xpath)} 0)) :named empty-list-field-has-zero-size-#{raw_field(xpath)}))")
         definition[:model_maxLength].times do |i|
           solver.declare_const(progress, value_var_for_list(xpath, i), translate_datatype_to_SMTLIB(definition[:datatype]), {:xpath => xpath, :xpath_element => definition[:xpath_element], :index => i, :datatype => definition[:datatype]})
           solver.to_solver(progress, "(assert (! (=> (<= #{size_var_for_list(xpath)} #{i}) (= #{value_var_for_list(xpath, i)} #{default_value_for_fielddef(definition)})) :named empty-list-field-has-no-value-for-#{raw_field(xpath)}-index-#{i}))") 
@@ -678,13 +747,13 @@ end
 def add_model_struct_to_doc(progress, struct, doc, model, prefix = nil)
   struct.each do |key, value|
     next if key == :validation_rules || key == :predicates || key == :parent_link || key == :struct_xpath_prefix || key == :additional_smtlib
+    if prefix then
+      xpath = "#{prefix}/#{key}"
+    else
+      xpath = key.to_s
+    end
+    model_value = model[xpath]
     if value[:type] == :field then
-      if prefix then
-        xpath = "#{prefix}/#{key}"
-      else
-        xpath = key.to_s
-      end
-      model_value = model[xpath]
       unless model_value then
         raise RuntimeError.new("xpath '#{xpath}' not contained in model.")
       end
@@ -696,12 +765,6 @@ def add_model_struct_to_doc(progress, struct, doc, model, prefix = nil)
       if node.is_a?(Nokogiri::XML::NodeSet) then
         node = node.first 
       end
-      if prefix then
-        xpath = "#{prefix}/#{key}"
-      else
-        xpath = key.to_s
-      end
-      model_value = model[xpath]
       xpath_element = value[:xpath_element]
       if Integer(model_value[:size]) > 0 then
         model_value[:value].slice(0, Integer(model_value[:size])).each do |mvalue|
@@ -709,19 +772,16 @@ def add_model_struct_to_doc(progress, struct, doc, model, prefix = nil)
         end
       end
     elsif value[:type] == :structure then
-      node = doc.add_child("<#{key}></#{key}>")
-      if node.is_a?(Nokogiri::XML::NodeSet) then
-        node = node.first 
-      end
       unless value[:ref] then
         raise RuntimeError.new("struct is broken: :structure #{key.inspect} does not have a :ref")
       end
-      if prefix then
-        new_prefix = "#{prefix}/#{key}"
-      else
-        new_prefix = key
+      if model_value[:exists] == true || model_value[:exists] == "true" then
+        node = doc.add_child("<#{key}></#{key}>")
+        if node.is_a?(Nokogiri::XML::NodeSet) then
+          node = node.first 
+        end
+        add_model_struct_to_doc(progress, value[:ref], node, model, xpath)
       end
-      add_model_struct_to_doc(progress, value[:ref], node, model, new_prefix)
     else
       raise RuntimeError.new("struct is broken: encountered unknown :type #{value[:type].inspect}")
     end
@@ -745,6 +805,12 @@ def collect_validation_rule_names(struct)
   return result
 end
 
+def set_standard_options(progress, solver)
+  solver.to_solver(progress, "(set-option :produce-unsat-cores true) ; enable generation of unsat cores")
+  solver.to_solver(progress, "(set-option :smt.core.minimize true) ; ensure that unsat cores are minimal")
+  solver.to_solver(progress, "")
+end
+
 def generate_doc(progress, message, output_filename, config, options)
   log = options[:log] || nil
   log.puts "generating doc #{output_filename}" if log
@@ -754,8 +820,7 @@ def generate_doc(progress, message, output_filename, config, options)
   z3 = Z3Solver.new(progress, z3path)
   begin
     model = z3.query_model(progress, options) do |solver|
-      solver.to_solver(progress, "(set-option :produce-unsat-cores true) ; enable generation of unsat cores")
-      solver.to_solver(progress, "")
+      set_standard_options(progress, solver)
       log.puts "translating structure" if log
       translate_structure_to_SMTLIB(progress, solver, message, :options => options, :config => config)
       solver.to_solver(progress, "")
@@ -830,33 +895,6 @@ def all_values_for_field(field)
   return values
 end
 
-def each_combination(fields, &block)
-  if fields.size < 1 then
-    return
-  end
-  if fields.size == 1 then
-    field = fields.first
-    values = field[1][:values].clone()
-    if field[1][:optional] == true then
-      values << nil
-    end
-    values.each do |value|
-      block.call({ field[0] => value })
-    end
-  else
-    first = fields.shift
-    values = first[1][:values].clone()
-    if first[1][:optional] == true then
-      values << nil
-    end
-    each_combination(fields) do |mapping|
-      values.each do |value|
-        block.call(mapping.merge({ first[0] => value }))
-      end
-    end
-  end
-end
-
 def calc_combinations_for_key_fields(key_fields)
   count = 1
   key_fields.each do |field|
@@ -923,46 +961,6 @@ def read_docs_from_log_file(log_filename)
   return result
 end
 
-def blocking_clause(docs, vars = docs.map{|e| e.keys}.flatten)
-  unless docs.empty?
-      codes = docs.map do |key_values|
-        value_codes = key_values.filter{|xpath,value| vars.include?(xpath) }.map do |xpath, value|
-          if value == nil then
-            "(= #{filled_var_for_field(xpath)} false)"
-          else
-            "(and (= #{filled_var_for_field(xpath)} true) (= #{value_var_for_field(xpath)} \"#{value}\"))"
-          end
-        end
-        if value_codes.empty? then
-          "true"
-        else
-          "(not (and #{value_codes.join(" ")}))"
-        end
-      end
-      return "" if codes.empty?
-      return "(assert (! (and #{codes.join(" ")}) :named blocking-clause))"
-  end
-  return nil
-end
-
-#def fixing_clause(key_values, fixed = key_value.keys)
-#  codes = []
-#  key_values.each do |xpath, value|
-#    if fixed.include?(xpath) then
-#      if value then
-#        codes << "(and (= #{filled_var_for_field(xpath)} true) (= #{value_var_for_field(xpath)} \"#{value}\"))"
-#      else
-#        codes << "(= #{filled_var_for_field(xpath)} false)"
-#      end
-#    end
-#  end
-#  if codes.empty? then
-#    return ""
-#  else
-#    return "(assert (! (and #{codes.join(" ")}) :named fixing-clause))"
-#  end
-#end
-
 def prepare_output_doc_filename(number, output_dir)
   chunk_number = number / 100000
   dirname = "#{output_dir}/#{chunk_number}"
@@ -972,30 +970,6 @@ def prepare_output_doc_filename(number, output_dir)
   return "#{dirname}/doc#{number}.xml"
 end
 
-def switch_blocking_clause(fixed, current_value, var_xpath, blocked_values)
-  clauses = []
-  blocked_values.each do |value|
-    if value != nil then
-      clauses << "(not (and (= #{filled_var_for_field(var_xpath)} true) (= #{value_var_for_field(var_xpath)} \"#{value}\")))"
-    else
-      clauses << "(not (= #{filled_var_for_field(var_xpath)} false))"
-    end
-  end
-  if fixed then
-    if current_value != nil then
-      result = "; switch fixing clause\n(assert (! (and (= #{filled_var_for_field(var_xpath)} true) (= #{value_var_for_field(var_xpath)} \"#{current_value}\")) :named switch_fixing_clause))"
-    else
-      result = "; switch fixing clause\n(assert (! (= #{filled_var_for_field(var_xpath)} false) :named switch_fixing_clause))"
-    end
-  else
-    result = ""
-  end
-  unless clauses.empty? then
-    result = result + "\n; switch blocking clause\n(assert (! (and #{clauses.join(" ")}) :named switch_blocking_clause))"
-  end
-  return result
-end
-
 def values_for_key_field(field)
   if field[:type] == :field then
     if field[:datatype] == :enum then
@@ -1024,14 +998,6 @@ def values_for_key_field(field)
   end
 end
 
-def fixing_clause(xpath, switched_info)
-  if switched_info[:current_value] == nil then
-    return "(assert (! (= #{filled_var_for_field(xpath)} false) :named fixing-clause-#{raw_field(xpath)}))"
-  else
-    return "(assert (! (and (= #{filled_var_for_field(xpath)} true) (= #{value_var_for_field(xpath)} \"#{switched_info[:current_value]}\")) :named fixing-clause-#{raw_field(xpath)}))"
-  end
-end
-
 def collect_key_fields(fkey, struct, prefix = nil)
   result = {}
   struct.each do |key, value|
@@ -1142,6 +1108,20 @@ def list_validation_rules(message)
   puts "Validation Rules:"
   rules.each { |r| puts "  #{r}" }
 end
+  
+def value_of_type(value, type)
+  if type == :string or type == :enum then
+    "\"#{value}\""
+  elsif type == :int then
+    value.to_s
+  elsif type == :date then
+    (Date.parse(value) -  Time.at(0).to_date).to_i.to_s
+  elsif type == :timestamp then
+    (Time.new(value) - Time.at(0)).to_i.to_s
+  else
+    raise RuntimeError.new("encountered unknown :datatype #{type.inspect}")
+  end
+end
 
 class CoreEnumerationAlgo
 
@@ -1180,14 +1160,6 @@ class CoreEnumerationAlgo
     "fixed(#{fixed.join(", ")})"
   end
   
-  def value_of_type(value, type)
-    if type == :string or type == :enum then
-      "\"#{value}\""
-    elsif type == :int then
-      value.to_s
-    end
-  end
-
   # prevent the var from taking values that already have been enumerated exhaustively
   def enumerate_blocking_clause(var_xpath, var_def, blocked)
     clauses = []
@@ -1237,8 +1209,7 @@ class CoreEnumerationAlgo
     z3 = Z3Solver.new(progress, z3path)
     begin
       model = z3.query_model(progress, options) do |solver|
-        solver.to_solver(progress, "(set-option :produce-unsat-cores true) ; enable generation of unsat cores")
-        solver.to_solver(progress, "")
+        set_standard_options(progress, solver)
         log.puts "translating structure" if log
         translate_structure_to_SMTLIB(progress, solver, message, :options => options, :config => config)
         solver.to_solver(progress, "")
@@ -1358,7 +1329,7 @@ class CoreEnumerationAlgo
     res = switched.times.to_a.map do |index|
       var_xpath = vars[index][0]
       "#{var_xpath}=#{assignment[var_xpath].inspect}"
-    end + ["#{vars[switched][0]}|#{blocked.map{|v| v.inspect}.join(",")}"]
+    end + ["#{vars[switched][0]}\{#{blocked.map{|v| v.inspect}.join(",")}}"]
     "{#{res.join(", ")}}"
   end
 
@@ -1513,8 +1484,6 @@ class CoreEnumerationAlgo
       end
     end
 
-    #progress.print_line "DEBUG: key_fields_list=#{key_fields_list.inspect}"
-
     cont_filename = "#{output_dir}/#{CONTINUATION_FILE}"
     if options[:continue] then
       unless File.exist?(cont_filename) then
@@ -1550,7 +1519,7 @@ class CoreEnumerationAlgo
 
         @on_new_doc = Proc.new { |num_doc, doc_filename, combination|
           # combination logging
-          log.puts "#{doc_filename} <- {#{combination.map{|k,v| "#{k}: #{v.inspect}"}.join(", ")}}"
+          log.puts "#{doc_filename} <- {#{combination.map{|k,v| "#{k}=#{v.inspect}"}.join(", ")}}"
 
           doc_counter += 1
           if options[:max_num_docs] && doc_counter >= options[:max_num_docs] then
@@ -1580,12 +1549,12 @@ class CoreEnumerationAlgo
       File.open(log_filename, log_mode) do |log|
         output_doc_filename = prepare_output_doc_filename(@num_tries, output_dir)
         key_values = generate_doc_return_key_values(progress, message, key, output_doc_filename, config, options)
-        log.puts "#{output_doc_filename} <- {#{key_values.map{|k,v| "#{k}: #{v.inspect}"}.join(", ")}}"
+        log.puts "#{output_doc_filename} <- {#{key_values.map{|k,v| "#{k}=#{v.inspect}"}.join(", ")}}"
         doc_counter += 1
         @num_tries += 1
         @on_new_doc = Proc.new { |num_doc, doc_filename, combination|
           # combination logging
-          log.puts "#{doc_filename} <- {#{combination.map{|k,v| "#{k}: #{v.inspect}"}.join(", ")}}"
+          log.puts "#{doc_filename} <- {#{combination.map{|k,v| "#{k}=#{v.inspect}"}.join(", ")}}"
 
           doc_counter += 1
           if options[:max_num_docs] && doc_counter >= options[:max_num_docs] then
@@ -1684,6 +1653,205 @@ def validate_model(message, prefix=nil)
   end
 end
 
+def validate_doc_against_schema(struct, doc)
+  root = doc.root
+  sdef = struct[root.name.to_sym]
+  unless sdef[:type] == :structure then
+    puts "ERROR: schema validation failed: root element should be a structure"
+  end  
+  # first, check that each doc element is defined for the struct
+  validate_doc_struct_against_schema(sdef[:ref], root, root.name)
+  # second, check that all required elements from the struct are actually present in the doc
+  validate_schema_against_doc_struct(sdef[:ref], root, root.name)
+end
+
+def validate_doc_struct_against_schema(struct, doc, prefix = nil)
+  doc.children.to_a.filter{|x| x.is_a?(Nokogiri::XML::Element) }.each do |c|
+    fdef = struct[c.name.to_sym]
+    if prefix then
+      xpath = "#{prefix}/#{c.name}"
+    else
+      xpath = c.name
+    end
+    if fdef
+      if fdef[:type] == :structure then
+        return unless validate_doc_struct_against_schema(fdef[:ref], c, xpath)
+      end
+    else
+      if prefix then
+        xpath = "#{prefix}/#{c.name}"
+      else
+        xpath = c.name
+      end
+      raise FatalError.new("ERROR: schema validation failed: #{c.name} of #{xpath} is present in document, but not defined in schema.")
+    end
+  end
+end
+
+def validate_schema_against_doc_struct(struct, doc, prefix = nil)
+  struct.each do |key, value|
+    next if key == :additional_smtlib || key == :validation_rules || key == :predicates || key == :parent_link || key == :struct_xpath_prefix
+      if prefix then
+        xpath = "#{prefix}/#{key}"
+      else
+        xpath = key
+      end
+    if value[:type] == :structure then
+      node = doc.at_xpath(key.to_s)
+      if node then
+        validate_schema_against_doc_struct(value[:ref], node, xpath)
+      else
+        if value[:optional] == false then
+          raise FatalError.new("ERROR: schema validation failed: non-optional structure #{xpath} not found in doc.")
+        end
+      end
+    elsif value[:type] == :field then
+      if value[:optional] == false then
+        unless doc.at_xpath(key.to_s) then
+          raise FatalError.new("ERROR: schema validation failed: non-optional field #{xpath} not found in doc.")
+        end
+      end
+    elsif value[:type] == :list then
+      if value[:optional] == false then
+        unless doc.at_xpath(key.to_s) then
+          raise FatalError.new("ERROR: schema validation failed: non-optional list #{xpath} not found in doc.")
+        end
+      end
+      list = doc.at_xpath(key.to_s)
+      if list then
+        list.children.to_a.each do |c|
+          next unless c.is_a?(Nokogiri::XML::Element)
+          unless c.name == value[:xpath_element] then
+            raise FatalError.new("ERROR: schema validation failed: encountered element #{c.name} in list #{xpath}, which should only contain #{value[:xpath_element]} elements.")
+          end
+        end
+      end
+    else
+      raise RuntimeError.new("Model error: encountered element #{xpath} of unknown type: #{value[:type]}.")
+    end
+  end  
+end
+
+def translate_doc_to_SMTLIB(progress, solver, struct, doc, hash = {})
+  options = hash[:options]
+  config = hash[:config]
+
+  solver.to_solver(progress, "; --- Document: ---")
+  translate_struct_in_doc_to_SMTLIB(progress, solver, struct, doc, nil, hash)
+end
+
+def translate_struct_in_doc_to_SMTLIB(progress, solver, struct, doc, prefix, hash = {})
+  options = hash[:options]
+  config = hash[:config]
+
+  struct.each do |key, value|
+    next if key == :additional_smtlib || key == :validation_rules || key == :predicates || key == :parent_link || key == :struct_xpath_prefix
+    if prefix then
+      xpath = "#{prefix}/#{key.to_s}"
+    else
+      xpath = key.to_s
+    end
+    if value[:type] == :structure then
+      node = doc.at_xpath(xpath)
+      if node then
+        info = {
+          :assertion_type => :doc_structure_exists,
+          :xpath => xpath,
+        }
+        assertionID = "doc-#{xpath.gsub('/', '-')}"
+        solver.associateAssertionIDWith(assertionID, info)
+        solver.to_solver(progress, "(assert (! (= #{exists_var_for_structure(xpath)} true) :named #{assertionID}))")
+
+        translate_struct_in_doc_to_SMTLIB(progress, solver, value[:ref], doc, xpath, hash)
+      else
+        info = {
+          :assertion_type => :doc_structure_not_exists,
+          :xpath => xpath,
+        }
+        assertionID = "doc-#{xpath.gsub('/', '-')}"
+        solver.associateAssertionIDWith(assertionID, info)
+        solver.to_solver(progress, "(assert (! (= #{exists_var_for_structure(xpath)} false) :named #{assertionID}))")
+      end
+    elsif value[:type] == :field then
+      node = doc.at_xpath(xpath)
+      if node then
+        fvalue = node.text
+        info = {
+          :assertion_type => :doc_field_filled,
+          :xpath => xpath,
+          :value => fvalue
+        }
+        fvalue_str = value_of_type(fvalue, value[:datatype])
+        assertionID = "doc-#{xpath.gsub('/', '-')}"
+        solver.associateAssertionIDWith(assertionID, info)
+        solver.to_solver(progress, "(assert (! (and (= #{filled_var_for_field(xpath)} true) (= #{value_var_for_field(xpath)} #{fvalue_str})) :named #{assertionID}))")
+      else
+        info = {
+          :assertion_type => :doc_field_empty,
+          :xpath => xpath,
+        }
+        assertionID = "doc-#{xpath.gsub('/', '-')}"
+        solver.associateAssertionIDWith(assertionID, info)
+        solver.to_solver(progress, "(assert (! (= #{filled_var_for_field(xpath)} false) :named #{assertionID}))")
+      end
+    elsif value[:type] == :list then
+      node = doc.at_xpath(xpath)
+      if node then
+        fvalues = []
+        node.children.to_a.each do |c|
+          next unless c.is_a?(Nokogiri::XML::Element)          
+          fvalues << c.text
+        end
+        info = {
+          :assertion_type => :doc_list_filled,
+          :xpath => xpath,
+          :values => fvalues
+        }
+        fvalue_str = value_of_type(fvalues, value[:datatype])
+        assertionID = "doc-#{xpath.gsub('/', '-')}"
+        solver.associateAssertionIDWith(assertionID, info)
+        clauses = []
+        fvalues.each_with_index do |fvalue, index|
+          clauses << "(= #{value_var_for_list(xpath,index)} #{value_of_type(fvalue, value[:datatype])})"
+        end
+        solver.to_solver(progress, "(assert (! (and (= #{filled_var_for_field(xpath)} true) (= #{size_var_for_list(xpath)} #{fvalues.size}) #{clauses.join(' ')}) :named #{assertionID}))")
+      else
+        info = {
+          :assertion_type => :doc_field_empty,
+          :xpath => xpath,
+        }
+        assertionID = "doc-#{xpath.gsub('/', '-')}"
+        solver.associateAssertionIDWith(assertionID, info)
+        solver.to_solver(progress, "(assert (! (= #{filled_var_for_field(xpath)} false) :named #{assertionID}))")
+      end
+    else
+      raise RuntimeError.new("Model Error: encountered unknown type #{value[:type].inspect}")
+    end
+  end
+end
+
+def validate_doc(progress, struct, doc, options, config)
+  options[:solverLog] = "validation.smt2"
+
+  z3path = config[:z3path] || DEFAULT_Z3_PATH
+  z3 = Z3Solver.new(progress, z3path)
+  begin
+    result = z3.query(progress, options) do |solver|
+      set_standard_options(progress, solver)
+      translate_structure_to_SMTLIB(progress, solver, struct, :options => options, :config => config)
+      translate_doc_to_SMTLIB(progress, solver, struct, doc, :options => options, :config => config)
+      solver.to_solver(progress, "")
+    end
+    unless result == true then
+      raise FatalError.new("VALIDATION FAILED! SMTLIB log was written to #{options[:solverLog]}.\n\n#{result}")
+    end
+  ensure
+    z3.close()
+  end
+
+  return true
+end
+
 def generate(message, argv, message_config_filename = nil)
   if ARGV[0] == "--help" || ARGV[0] == "-help" || ARGV[0] == "help" then
     puts USAGE
@@ -1716,6 +1884,12 @@ def generate(message, argv, message_config_filename = nil)
     elsif opt == "-max-num-docs" then
       options[:max_num_docs] = Integer(argv.shift)
       puts "flag -max-num-docs used. Will stop after generating #{options[:max_num_docs]} documents."
+    elsif opt == "-validate" then
+      if options.has_key?(:validate_files) then
+        options[:validate_files] << argv.shift
+      else
+        options[:validate_files] = [argv.shift]
+      end
     else
       puts "FATAL: unknown option #{opt.inspect}."
       puts USAGE
@@ -1751,7 +1925,17 @@ def generate(message, argv, message_config_filename = nil)
 
   introduce_parent_links(message)
 
-  if options[:count_docs_for_key] then
+  if options[:validate_files] then
+    puts "using #{options[:date_now]} as [Date.now]"
+    puts "using #{options[:timestamp_now]} as [Timestamp.now]"
+    options[:validate_files].each do |filename|
+      puts "validating file #{filename}"
+      doc = Nokogiri::XML(File.read(filename))
+      validate_doc_against_schema(message, doc)
+      progress = ProgressBar.new(1)
+      validate_doc(progress, message, doc, options, config)
+    end
+  elsif options[:count_docs_for_key] then
     puts "there are #{calc_combinations(message, options[:count_docs_for_key])} combinations."
   elsif options[:docs_for_key] then
     puts "using #{options[:date_now]} as [Date.now]"

data/lib/solver-lib.rb

@@ -1,14 +1,6 @@
-require 'open3'
-
-FTYPE_MANDATORY = 0
-FTYPE_OPTIONAL  = 1
-
-SUBF_AND = 0
-SUBF_OR  = 1
-SUBF_XOR = 2
-
-LOG_DIR = 'logs'
+#!/usr/bin/ruby
 
+require 'open3'
 
 
 class SolverSession
@@ -121,6 +113,13 @@ class SolverSession
     return nextAssertionID
   end
 
+  def associateAssertionIDWith(assertionID, hash)
+    if @associations.has_key?(assertionID) then
+      raise RuntimeError.new("AssertionID #{assertionID.inspect} already has info associated with it!")
+    end
+    @associations[assertionID] = hash
+  end
+
   def getAssociationForAssertionID(assertionID)
     return @associations[assertionID]
   end
@@ -167,32 +166,89 @@ class Z3Solver
     Thread.kill(@z3thr)
   end
 
-  def query(&block)
-    solver = SolverSession.new(@z3in, @z3outAndErr)
+  def query(progress, options, &block)
+    unless options[:solverLog]
+      raise RuntimeError.new("No solverLog specified, but the option :solverLog is required!")
+    end
+    progress.print_line("calling solver (solver-log is written to #{options[:solverLog]})")
+    solver = SolverSession.new(@z3in, @z3outAndErr, options[:solverLog])
 
     block.call(solver)
 
-    solver.toSolver "(check-sat)"
-    result = solver.fromSolver()
+    solver.to_solver(progress, "(check-sat)")
+    result = solver.from_solver(progress)
+    explanation = true
     if result.chomp == "sat"
         # model is not contradictory -> continue
     elsif result.chomp == "unsat"
         # model is contradictory -> add a message
 
-        solver.toSolver("(get-unsat-core)")
-        unsat_core = solver.fromSolver()
-        explanation = build_explanation_based_on_unsat_core(solver, sid, unsat_core)
-        messages << {:type => :issue, :text => "Model is contradictory", :explanation => explanation}
-        solver.writeProtocolToFile("contradictions.smt2")
+        solver.to_solver(progress, "(get-unsat-core)")
+        unsat_core = solver.from_solver(progress)
+        explanation = parse_unsat_core(solver, unsat_core)
     else
-      handleSolverError(solver, result)
+      handleSolverError(progress, solver, options, result)
     end
 
-    messages = []
-    solver.toSolver "(reset)"
-    solver.toSolver "(set-logic ALL)"
-    solver.toSolver "(set-option :produce-unsat-cores true)"
-    return messages
+    solver.to_solver(progress, "(reset)")
+    solver.to_solver(progress, "(set-logic ALL)") 
+    solver.to_solver(progress, "(set-option :produce-unsat-cores true)") 
+    return explanation
+  end
+
+  def display_assertion(assertion, solver)
+    if assertion =~ /validation_rule_(.*)_instance_(.*)/ then
+      return "Validation rule #{$1} of structure #{$2.gsub("_", "/")}"
+    else
+      info = solver.getAssociationForAssertionID(assertion)
+      if info then
+        if info[:assertion_type] == :doc_field_filled then
+          return "Field #{info[:xpath]} contains value #{info[:value].inspect} in document"
+        elsif info[:assertion_type] == :doc_field_empty then
+          return "Field #{info[:xpath]} is empty in document"
+        elsif info[:assertion_type] == :doc_structure_exists then
+          return "Structure #{info[:xpath]} exists in document"
+        elsif info[:assertion_type] == :doc_structure_not_exists then
+          return "Structure #{info[:xpath]} does not exist in document"
+        elsif info[:assertion_type] == :constraint then
+          if info[:constraint_type] == :min then
+            return "Field #{info[:xpath]} has a minimum value of #{info[:value]}."
+          elsif info[:constraint_type] == :max then
+            return "Field #{info[:xpath]} has a maximum value of #{info[:value]}."
+          elsif info[:constraint_type] == :required then
+            return "Field #{info[:xpath]} is required."
+          else
+            p info
+            raise RuntimeError.new("encountered unknown :constraint_type #{info[:constraint_type].inspect} for assertionID #{assertion.inspect}")
+          end
+        else
+          raise RuntimeError.new("encountered unknown :assertion_type #{info[:assertion_type].inspect} for assertionID #{assertion.inspect}")
+        end
+      else
+        return assertion
+      end
+    end
+  end
+
+  def parse_unsat_core(solver, unsat_core)
+    unsat_core = unsat_core.chomp
+    # TODO: implement
+    unless unsat_core =~ /\((.*)\)/ then
+      raise RuntimeError.new("could not parse unsat core: #{unsat_core.inspect}")
+    end
+    list = $1.split(" ")
+
+    result = "EXPLANATION:\n"
+    result += "The following values\n"
+
+    list.filter{|a| a.start_with?("doc-")}.each do |assertion|
+      result += "- #{display_assertion(assertion, solver)} (#{assertion})\n"
+    end
+    result += "\nviolate the following constraints\n"
+    list.filter{|a| !a.start_with?("doc-")}.each do |assertion|
+      result += "- #{display_assertion(assertion, solver)} (#{assertion})\n"
+    end
+    return result
   end
 
   # main entry point!
@@ -257,10 +313,13 @@ class Z3Solver
                 end
               end
             elsif varname.end_with?("-size") then
-              unless model[xpath][:type] == :list then
-                raise RuntimeError.new("inconsistent model: xpath #{xpath} should be a list, not a #{model[xpath][:type]}.")
+              unless model[xpath][:type] == :list || model[xpath][:type] == :field then
+                raise RuntimeError.new("inconsistent model: xpath #{xpath} should be a list or a field, not a #{model[xpath][:type]}.")
+              end
+              if model[xpath][:type] == :field then
+                model[xpath][:type] = :list
               end
-              model[xpath][:value] = value
+              model[xpath][:size] = Integer(value)
             elsif varname.start_with?("struct-") && varname.end_with?("-exists") then
               unless model[xpath][:type] == :struct then
                 raise RuntimeError.new("inconsistent model: xpath #{xpath} should be a struct, not a #{model[xpath][:type]}.")

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: mbt-gen
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - FM-enthusiast
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-23 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -36,13 +35,12 @@ files:
 - lib/progress.rb
 - lib/regexp-to-smtlib.rb
 - lib/solver-lib.rb
-homepage: https://github.com/FM-enthusiast/MBT-gen
+homepage: https://codeberg.org/FM-enthusiast/MBT-gen
 licenses:
 - GPL-3.0-only
 metadata:
-  bug_tracker_uri: https://github.com/FM-enthusiast/MBT-gen/issues
-  source_code_uri: https://github.com/FM-enthusiast/MBT-gen
-post_install_message:
+  bug_tracker_uri: https://codeberg.org/FM-enthusiast/MBT-gen/issues
+  source_code_uri: https://codeberg.org/FM-enthusiast/MBT-gen
 rdoc_options: []
 require_paths:
 - lib
@@ -58,8 +56,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements:
 - an SMT-solver. Z3 is recommended, it can be obtained from https://github.com/Z3Prover/z3
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.7
 specification_version: 4
 summary: test data generator for Model-based testing
 test_files: []