mbt-gen 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 056ec1e0d6d661c5c4a092e4a7e879f610a7524dfa63fb7faf9779d8fc4bfc6e
-  data.tar.gz: 20f715037f76a5e23dd5407416018ff7c2cbf3c64a616c6fe32117bc0b411a20
+  metadata.gz: 8b69ab00ef224ac052d2f5897cce4c620c72a3630f9e6da9eaabb7cc7277904f
+  data.tar.gz: ad905f43225a8680663ec4068a2acd65845090e238da9c8b902008e9c118e1e8
 SHA512:
-  metadata.gz: 7cfca600b07970cc752fa96da6e9dc1052af81024e94c87f581b49632cb414e13d6e71c05dfbb7dc51eab907e3f0ef504ac880994b59cd83347a038c8709fbd5
-  data.tar.gz: 2ba5fa686c5a8894431e714481953ea2c4989de0825e14c526e273ba10e798250003492195b5163a69ebfe53e1cba7d9b243d9f9c5ae82806484b3026a4e793a
+  metadata.gz: 2d1d2d4393f92efad0eb54968c3029aa7030551ce296483890b4b7dbe57cdb3ba8fe4224ef7cd2d6dacc0f28df482b14eb3f373b6e4394e45478ccee4da3147a
+  data.tar.gz: ffc27db25c445aa64b856a0b2763085cbb6469675fdd5bf89730d5e6cd6a626a615abe5be2ac1b7f02d69972e8b6ab11b0b7d270c13340ffc70c8442a64914ff

data/lib/mbt-gen.rb

@@ -812,21 +812,17 @@ def set_standard_options(progress, solver)
 end
 
 def generate_doc(progress, message, output_filename, config, options)
+  raise RuntimeError.new("option :solverFactory is required") unless options[:solverFactory]
   log = options[:log] || nil
   log.puts "generating doc #{output_filename}" if log
   options[:solverLog] = options[:solverLog] || "#{output_filename}.smt2"
 
-  z3path = config[:z3path] || DEFAULT_Z3_PATH
-  z3 = Z3Solver.new(progress, z3path)
-  begin
-    model = z3.query_model(progress, options) do |solver|
-      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, "")
-    end
-  ensure
-    z3.close()
+  solverFactory = options[:solverFactory]
+  model = solverFactory.query_model(options) do |solver|
+    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, "")
   end
 
   if model then
@@ -925,6 +921,9 @@ end
 
 def calc_combinations(message, key)
   key_fields = collect_key_fields(key, message)
+  if key_fields.empty?
+    raise FatalError.new("unknown key: #{key}")
+  end
   return calc_combinations_for_key_fields(key_fields)
 end
 
@@ -1199,23 +1198,19 @@ class CoreEnumerationAlgo
   end
 
   def generate_doc_return_key_values(progress, message, key, output_filename, config, options)
+    raise RuntimeError.new("option :solverFactory is required.") unless options[:solverFactory]
     log = options[:log] || nil
     log.puts "generating doc #{output_filename}" if log
     options[:solverLog] = log_filename_for_output_filename(output_filename)
 
     key_fields = collect_key_fields(key, message)
 
-    z3path = config[:z3path] || DEFAULT_Z3_PATH
-    z3 = Z3Solver.new(progress, z3path)
-    begin
-      model = z3.query_model(progress, options) do |solver|
-        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, "")
-      end
-    ensure
-      z3.close()
+    solverFactory = options[:solverFactory]    
+    model = solverFactory.query_model(options) do |solver|
+      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, "")
     end
 
     if model then
@@ -1233,9 +1228,12 @@ class CoreEnumerationAlgo
     end
   end
 
-  def store_continuation_point(doc_number, state, assignment, new_assignment, filename)
+  def store_continuation_point(doc_number, state, assignment, new_assignment, filename, options, time)
     File.open(filename, "w") do |f|
-      f.puts("#{doc_number};#{@num_docs};state(#{state.map{|s| if s then "[#{s.map{|v| v.inspect}.join(",")}]" else "nil" end}.join("#")});assignment(#{assignment.to_a.map{|k,v| "#{k}:#{v.inspect}"}.join(",")});new_assignment(#{new_assignment.to_a.map{|k,v| "#{k}:#{v.inspect}"}.join(",")})")
+      state_str = "state(#{state.map{|s| if s then "[#{s.map{|v| v.inspect}.join(",")}]" else "nil" end}.join("#")})"
+      assignment_str = "assignment(#{assignment.to_a.map{|k,v| "#{k}:#{v.inspect}"}.join(",")})"
+      new_assignment_str = "new_assignment(#{new_assignment.to_a.map{|k,v| "#{k}:#{v.inspect}"}.join(",")})"
+      f.puts("#{doc_number};#{@num_docs};#{state_str};#{assignment_str};#{new_assignment_str};#{time}")
     end
   end
 
@@ -1316,7 +1314,8 @@ class CoreEnumerationAlgo
     state = CoreEnumerationAlgo.parse_state(split[2])
     assignment = CoreEnumerationAlgo.parse_assignment(split[3])
     new_assignment = CoreEnumerationAlgo.parse_assignment(split[4])
-    return [doc_number, num_docs, state, assignment, new_assignment]
+    processessing_time = Integer(split[5])
+    return [doc_number, num_docs, state, assignment, new_assignment, processessing_time]
   end
 
   # TODO: logging
@@ -1332,13 +1331,14 @@ class CoreEnumerationAlgo
     end + ["#{vars[switched][0]}\{#{blocked.map{|v| v.inspect}.join(",")}}"]
     "{#{res.join(", ")}}"
   end
+  
 
   # core algo
-  def enumerate(progress, switched, vars, assignment, message, key, output_dir, config, options, state = [nil] * vars.size())
-    enumerate(progress, switched+1, vars, assignment, message, key, output_dir, config, options, state) if switched < vars.size()-1
+  def enumerate(progress, switched, vars, assignment, message, key, output_dir, config, options, state = [nil] * vars.size(), start_time, prior_processing_time)
+    enumerate(progress, switched+1, vars, assignment, message, key, output_dir, config, options, state, start_time, prior_processing_time) if switched < vars.size()-1
     is_finite_state = keys_are_finite_state(vars)
     if state[switched] == nil then
-      blocked = [assignment[vars[switched][0]]]
+      blocked = [assignment[vars[switched][0]]] 
       state[switched] = blocked
     else
       blocked = state[switched] + [assignment[vars[switched][0]]]
@@ -1354,24 +1354,33 @@ class CoreEnumerationAlgo
       output_doc_filename = prepare_output_doc_filename(@num_tries, output_dir)
       new_assignment = generate_sparse_doc(progress, message, key, config, options, clauses, output_doc_filename)
       generated_doc_number = @num_tries
-      store_continuation_point(generated_doc_number, state, assignment, new_assignment, "#{output_dir}/#{CONTINUATION_FILE}")
+      time = prior_processing_time + (Time.now().to_i - options[:timestamp_now])
+      store_continuation_point(generated_doc_number, state, assignment, new_assignment, "#{output_dir}/#{CONTINUATION_FILE}", options, time)
+      progress.print_line "STORING continuation point"
+      progress.print_line "|time=#{time}"
+      progress.print_line "|doc_number=#{generated_doc_number}"
+      progress.print_line "|num_docs=#{@num_docs}"
+      progress.print_line "|state=#{state.inspect}"
+      progress.print_line "|assignment=#{assignment.inspect}"
+      progress.print_line "|new_assignment=#{new_assignment.inspect}"
+
       if is_finite_state then
-        progress.report_progress(determine_progress(state, vars))
+        progress.report_progress(determine_progress(state, vars), start_time, prior_processing_time, @num_docs)
       else
-        progress.report_progress(nil)
+        progress.report_progress(nil, start_time, prior_processing_time, @num_docs)
       end
       @num_tries += 1
       if new_assignment then # sat
         @num_docs += 1
         @on_new_doc.call(generated_doc_number, output_doc_filename, new_assignment) if @on_new_doc
         if switched < vars.size()-1 then
-          enumerate(progress, switched+1, vars, new_assignment, message, key, output_dir, config, options, state)
+          enumerate(progress, switched+1, vars, new_assignment, message, key, output_dir, config, options, state, start_time, prior_processing_time)
         end
         blocked << new_assignment[vars[switched][0]]
         state[switched] = blocked
         found = true
       else # unsat
-        @on_unsat.call(generated_doc_number, log_filename_for_output_filename(output_doc_filename), display_combination_space(assignment, vars, switched, blocked)) if @on_unsat
+        @on_unsat.call(generated_doc_number, log_filename_for_output_filename(output_doc_filename), display_combination_space(assignment, vars, switched, blocked), switched) if @on_unsat
         found = false
       end
     end
@@ -1437,18 +1446,17 @@ class CoreEnumerationAlgo
     return true
   end
 
-  def generate_docs_for_key(message, key, output_dir, config, options)
+  def generate_docs_for_key(progress, message, key, output_dir, config, options)
 
+    prior_processing_time = 0
+    start_time = options[:timestamp_now]
     number_of_combinations = calc_combinations(message, key)
     if number_of_combinations.is_a?(String) then
-      progress = ProgressBar.new(100000000000000)
+      progress.set_max(100000000000000)
     else
-      progress = ProgressBar.new(number_of_combinations)
+      progress.set_max(number_of_combinations)
     end
-    begin
-    ensure
-    end
-    progress.report_progress(0.0)
+    progress.report_progress(0.0, start_time, prior_processing_time, 0)
     progress.print_line "generating sparse documents efficiently..."
     progress.print_line "there is a theoretical maximum of #{number_of_combinations} combinations."
     progress.print_line "Note, however, that we are generating only those documents that are valid, which are usually much less."
@@ -1489,21 +1497,22 @@ class CoreEnumerationAlgo
       unless File.exist?(cont_filename) then
         raise FatalError.new("FATAL: file #{cont_filename} not found. There seems to be no continuation point to continue from...")
       end
-      doc_number, num_docs, state, assignment, new_assignment = CoreEnumerationAlgo.parse_continuation_point(File.read(cont_filename).chomp)
+      doc_number, num_docs, state, assignment, new_assignment, prior_processing_time = CoreEnumerationAlgo.parse_continuation_point(File.read(cont_filename).chomp)
       if is_final_state(state, new_assignment, key_fields_list) then
-        progress.report_progress(number_of_combinations)
+        progress.report_progress(number_of_combinations, start_time, prior_processing_time, num_docs)
         raise FatalError.new("FATAL: The enumeration is finished. There is nothing left to do. Resuming the enumeration hence does not make sense.")
       end
       progress.print_line "RESUMING enumeration from the following continuation point:"
+      progress.print_line "|time=#{prior_processing_time}"
       progress.print_line "|doc_number=#{doc_number}"
       progress.print_line "|num_docs=#{num_docs}"
       progress.print_line "|state=#{state.inspect}"
       progress.print_line "|assignment=#{assignment.inspect}"
       progress.print_line "|new_assignment=#{new_assignment.inspect}"
       if keys_are_finite_state(key_fields_list) then
-        progress.report_progress(determine_progress(state, key_fields_list))
+        progress.report_progress(determine_progress(state, key_fields_list), start_time, prior_processing_time, num_docs)
       else
-        progress.report_progress(nil)
+        progress.report_progress(nil, start_time, prior_processing_time, num_docs)
       end
 
       if new_assignment && !new_assignment.empty? then
@@ -1514,15 +1523,13 @@ class CoreEnumerationAlgo
       @num_tries = doc_number+1 # we do not want to overwrite the last document written before the STOP
       number_of_combinations += 1 # account for this in the safety mechanism
       @num_docs = num_docs
-      doc_counter = 0
       File.open(log_filename, log_mode) do |log|
 
         @on_new_doc = Proc.new { |num_doc, doc_filename, combination|
           # combination logging
           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
+          if options[:max_num_docs] && @num_docs >= options[:max_num_docs] then
             raise NormalProgramTermination.new("-max-num-docs exceeded. Stopping!")
           end
 
@@ -1531,33 +1538,27 @@ class CoreEnumerationAlgo
             raise RuntimeError.new("This should never happen! Number of combinations exceeded. #{@num_docs} documents generated, but there are only #{number_of_combinations} possible combinations of the key vars.")
           end
         }
-        @on_unsat = Proc.new { |num_doc, log_filename, combination_str|
+        @on_unsat = Proc.new { |num_doc, log_filename, combination_str, switched|
               log.puts "CONTRADICTION (see: #{log_filename}) <- #{combination_str}"
               progress.print_line "doc#{num_doc} NOT generated"
-              progress.print_line "No more valid combinations of the free vars could be found. -> Switching"
+              progress.print_line "No more valid combinations of the free vars could be found. -> Switching (var #{switched})"
         }
 
         # core algo - resume from state
-        enumerate(progress, 0, key_fields_list, assignment, message, key, output_dir, config, options, state)
+        enumerate(progress, 0, key_fields_list, assignment, message, key, output_dir, config, options, state, start_time, prior_processing_time)
       end
     else
       # init safety mechanism
       @num_tries = 0
       @num_docs = 0
-      doc_counter = 0
       # first try - a freely generated document
       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(", ")}}"
-        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(", ")}}"
 
-          doc_counter += 1
-          if options[:max_num_docs] && doc_counter >= options[:max_num_docs] then
+          if options[:max_num_docs] && @num_docs >= options[:max_num_docs] then
             raise NormalProgramTermination.new("-max-num-docs exceeded. Stopping!")
           end
 
@@ -1568,19 +1569,28 @@ class CoreEnumerationAlgo
             end
           end
         }
-        @on_unsat = Proc.new { |num_doc, log_filename, combination_str|
+        @on_unsat = Proc.new { |num_doc, log_filename, combination_str, switched|
               log.puts "CONTRADICTION (see: #{log_filename}) <- #{combination_str}"
               progress.print_line "doc#{num_doc} NOT generated"
-              progress.print_line "No more valid combinations of the free vars could be found. -> Switching"
+              progress.print_line "No more valid combinations of the free vars could be found. -> Switching (var #{switched})"
         }
+        key_values = generate_doc_return_key_values(progress, message, key, output_doc_filename, config, options)
+        @num_tries += 1
+        if key_values then
+          @num_docs += 1
+          @on_new_doc.call(@num_tries, output_doc_filename, key_values)
+        else
+          # NOTE: this only occurs when the model is inconsistent and has no valid documents
+          progress.print_line("ERROR: Model inconsistent - no valid documents could be found.")
+          @on_unsat.call(@num_tries, log_filename_for_output_filename(output_doc_filename), "{}", 0)
+        end
 
         # core algo - start enumeration
-        enumerate(progress, 0, key_fields_list, key_values, message, key, output_dir, config, options)
+        enumerate(progress, 0, key_fields_list, key_values, message, key, output_dir, config, options, start_time, prior_processing_time)
       end
-      
-      progress.print_line "No more valid documents could be found. -> Exiting"
-      progress.report_progress(number_of_combinations)
     end
+    progress.print_line "No more valid documents could be found. -> Exiting"
+    progress.report_progress(number_of_combinations, start_time, prior_processing_time, @num_docs)
   end
 end
 
@@ -1831,27 +1841,33 @@ def translate_struct_in_doc_to_SMTLIB(progress, solver, struct, doc, prefix, has
 end
 
 def validate_doc(progress, struct, doc, options, config)
+  raise RuntimeError.new("option :solverFactory is required") unless options[:solverFactory]
   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()
+  solverFactory = options[:solverFactory]
+  result = solverFactory.query(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
 
   return true
 end
 
+def generate_unused_logfile_name()
+  number = 0
+  result = "logs/#{number}.log"
+  while File.exist?(result) do
+    number += 1
+    result = "logs/#{number}.log"
+  end
+  result
+end
+
 def generate(message, argv, message_config_filename = nil)
   if ARGV[0] == "--help" || ARGV[0] == "-help" || ARGV[0] == "help" then
     puts USAGE
@@ -1898,61 +1914,63 @@ def generate(message, argv, message_config_filename = nil)
     opt = argv.shift
   end
 
-  unless options[:negated_validation_rules].empty? then
-    puts "negating rules: #{options[:negated_validation_rules].join(", ")}"
+  ProgressBar.logging(1, generate_unused_logfile_name()) do |progress|
+    unless options[:negated_validation_rules].empty? then
+      progress.print_line "negating rules: #{options[:negated_validation_rules].join(", ")}"
+
+      rules = collect_validation_rule_names(message)
+      unknown_negated_rules = options[:negated_validation_rules].filter { |rule_name| !rules.include?(rule_name) } 
+      unless unknown_negated_rules.empty? then  
+        throw RuntimeError.new("unknown negated rules #{unknown_negated_rules.join(", ")}")
+      end
 
-    rules = collect_validation_rule_names(message)
-    unknown_negated_rules = options[:negated_validation_rules].filter { |rule_name| !rules.include?(rule_name) } 
-    unless unknown_negated_rules.empty? then  
-      throw RuntimeError.new("unknown negated rules #{unknown_negated_rules.join(", ")}")
     end
 
-  end
+    if File.exist?(CONFIG_FILE) then
+      config = YAML.load_file(CONFIG_FILE)
+    else
+      config = DEFAULT_CONFIG
+      File.open(CONFIG_FILE, "w") do |f|
+        f.puts(config.to_yaml)
+      end
+      progress.print_line "No config file found. Default config written to #{CONFIG_FILE}"
+    end
+    if message_config_filename then
+      message_config = YAML.load_file(message_config_filename)
+      config = config.merge(message_config)
+    end
 
-  if File.exist?(CONFIG_FILE) then
-    config = YAML.load_file(CONFIG_FILE)
-  else
-    config = DEFAULT_CONFIG
-    File.open(CONFIG_FILE, "w") do |f|
-      f.puts(config.to_yaml)
-    end
-    puts "No config file found. Default config written to #{CONFIG_FILE}"
-  end
-  if message_config_filename then
-    message_config = YAML.load_file(message_config_filename)
-    config = config.merge(message_config)
-  end
-
-  introduce_parent_links(message)
-
-  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]"
-    puts "using #{options[:timestamp_now]} as [Timestamp.now]"
-    validate_model(message)
-    CoreEnumerationAlgo.new().generate_docs_for_key(message, options[:docs_for_key], OUTPUT_DIR, config, options)
-  elsif options[:list_keys] then
-    list_keys(message)
-  elsif options[:list] then
-    list_fields_and_structures(message, options[:list])
-  elsif options[:list_validation_rules] then
-    list_validation_rules(message)
-  else
-    puts "using #{options[:date_now]} as [Date.now]"
-    puts "using #{options[:timestamp_now]} as [Timestamp.now]"
-    validate_model(message)
-    progress = ProgressBar.new(1)
-    generate_doc(progress, message, OUTPUT_FILE, config, options)
+    introduce_parent_links(message)
+    z3path = config[:z3path] || DEFAULT_Z3_PATH
+    options[:solverFactory] = SolverFactory.new(progress, z3path)
+
+    if options[:validate_files] then
+      progress.print_line "using #{options[:date_now]} as [Date.now]"
+      progress.print_line "using #{options[:timestamp_now]} as [Timestamp.now]"
+      options[:validate_files].each do |filename|
+        progress.print_line "validating file #{filename}"
+        doc = Nokogiri::XML(File.read(filename))
+        validate_doc_against_schema(message, doc)
+        validate_doc(progress, message, doc, options, config)
+      end
+    elsif options[:count_docs_for_key] then
+      progress.print_line "there are #{calc_combinations(message, options[:count_docs_for_key])} combinations."
+    elsif options[:docs_for_key] then
+      progress.print_line "using #{options[:date_now]} as [Date.now]"
+      progress.print_line "using #{options[:timestamp_now]} as [Timestamp.now]"
+      validate_model(message)
+      CoreEnumerationAlgo.new().generate_docs_for_key(progress, message, options[:docs_for_key], OUTPUT_DIR, config, options)
+    elsif options[:list_keys] then
+      list_keys(message)
+    elsif options[:list] then
+      list_fields_and_structures(message, options[:list])
+    elsif options[:list_validation_rules] then
+      list_validation_rules(message)
+    else
+      progress.print_line "using #{options[:date_now]} as [Date.now]"
+      progress.print_line "using #{options[:timestamp_now]} as [Timestamp.now]"
+      validate_model(message)
+      generate_doc(progress, message, OUTPUT_FILE, config, options)
+    end
   end
 end

data/lib/progress.rb

@@ -1,9 +1,14 @@
 #!/usr/bin/ruby
 
+require 'fileutils'
+
 class Progress
     
-    def initialize()
+    def initialize(logfilename)
         @last_line = ""
+        dir = File.dirname(logfilename)
+        FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+        @logfile = File.open(logfilename, "w")
     end
 
     def update_last_line(last_line)
@@ -13,27 +18,64 @@ class Progress
     end
 
     def print_line(line)
+       @logfile.puts(line)
+       @logfile.flush()
        print "\033[M#{line}\n#{@last_line}"
        $stdout.flush()
     end
 end
 
 class ProgressBar < Progress
-    def initialize(max)
+    def initialize(max, logfilename)
+        super(logfilename)
         @max = max.to_f
     end
 
+    def set_max(value)
+      @max = value.to_f
+    end
+
     def render_bar(current, length)
         bars = (current.to_f * length.to_f).floor
         "=" * bars + ">" + " " * (length - bars)
     end
 
-    def report_progress(progress)
+    def processing_time(start_time, prior_processessing_time)
+      total_sec = prior_processessing_time + (Time.now().to_i - start_time)
+      sec = total_sec
+      days = sec / (3600*24)
+      sec -= days * (3600*24)
+      hours = sec / 3600
+      sec -= hours * 3600
+      min = sec / 60
+      sec -= min * 60
+      if days > 0 then
+        return format("%d:%02d:%02d:%02d", days, hours, min, sec)
+      else
+        if hours > 0 then
+          return format("%02d:%02d:%02d", hours, min, sec)
+        else
+          return format("%02d:%02d", min, sec)
+        end
+      end
+    end
+
+    def report_progress(progress, start_time, prior_processessing_time, num_docs)
+      time_str = processing_time(start_time, prior_processessing_time)
       if progress then
         current = (progress.to_f / @max)
-        update_last_line("[#{render_bar(current, 40)}] combinations covered: #{progress}/#{@max} (#{format("%.8f", current * 100.0)}%)")
+        update_last_line("#{time_str} [#{render_bar(current, 40)}] combinations covered: #{progress}/#{@max} (#{format("%.8f", current * 100.0)}%), docs generated: #{num_docs}")
       else
-        update_last_line("[... ? ... ? ... ? ...] combinations covered: ?/∞ (?%)")
+        update_last_line("#{time_str} [... ? ... ? ... ? ...] combinations covered: ?/∞ (?%), docs generated: #{num_docs}")
+      end
+    end
+
+    def self.logging(max, logfile, &block)
+      progress = ProgressBar.new(max, logfile)
+      begin
+        block.call(progress)
+      ensure
+        progress.print_line("Output written to #{logfile}")
       end
     end
 end

data/lib/solver-lib.rb

@@ -5,9 +5,9 @@ require 'open3'
 
 class SolverSession
 
-  def initialize(z3in, z3outAndErr, logFileName)
-    @z3in = z3in
-    @z3outAndErr = z3outAndErr
+  def initialize(solverFactory, logFileName)
+    @solverFactory = solverFactory
+    @solver = @solverFactory.new_solver()
     @protocol_filename = logFileName
     @protocol = File.open(@protocol_filename, "w")
     @assertCounter = -1
@@ -15,13 +15,26 @@ class SolverSession
     @consts = {}
   end
 
+  def switch_solver(progress)
+    @solver.close()
+    @solver = @solverFactory.new_solver()
+    # re-feed the session protocol into the new solver to get it up-to-date
+    @protocol.close()
+    File.open(@protocol_filename, "r") do |protocol|
+      protocol.each_line do |line|
+        to_solver(progress, line)
+      end
+    end
+    @protocol = File.open(@protocol_filename, "a")
+  end
+
   def emptyReadBuffer(progress)
     empty = false
     while !empty do
       begin
         c = ""
-        @z3outAndErr.read_nonblock(1, c)
-        line = c + @z3outAndErr.gets
+        @solver.z3outAndErr.read_nonblock(1, c)
+        line = c + @solver.z3outAndErr.gets
         checkLineForSolverError(line, progress)
         @protocol.puts("; Solver Response: #{line}")
       rescue Errno::EWOULDBLOCK
@@ -45,16 +58,27 @@ class SolverSession
 
   def to_solver(progress, line)
     emptyReadBuffer(progress);
-    @protocol.puts(line)
-    begin
-      @z3in.puts(line)
-    rescue Errno::EINVAL
-      progress.print_line "ERROR: could not write the line #{line.inspect} to the solver."
-      writeProtocolToFile("failure.smt2")
-    rescue Errno::EPIPE
-      writeProtocolToFile("failure.smt2")
-      throw RuntimeError.new("Broken Pipe")
+    success = false
+    while (!success) do
+      begin
+        @solver.z3in.puts(line)
+        success = true
+      rescue Errno::EINVAL => e
+        progress.print_line("DEBUG: Invalid argument to puts(): #{line.inspect}")
+        progress.print_line("An Error occured: #{e.message}")
+        e.backtrace.each { |stline| progress.print_line(stline) }
+        progress.print_line("=> Switching Solver")
+        switch_solver(progress)
+        progress.print_line("=> Switch successful. Trying again.")
+      rescue Errno::EPIPE => e
+        progress.print_line("An Error occured: #{e.message}")
+        e.backtrace.each { |stline| progress.print_line(stline) }
+        progress.print_line("=> Switching Solver")
+        switch_solver(progress)
+        progress.print_line("=> Switch successful. Trying again.")
+      end
     end
+    @protocol.puts(line)
   end
 
   def checkLineForSolverError(line, progress)
@@ -65,14 +89,14 @@ class SolverSession
 
 
   def from_solver(progress)
-    result = @z3outAndErr.gets
+    result = @solver.z3outAndErr.gets(chomp: true)
     checkLineForSolverError(result, progress)
     @protocol.puts("; Solver Response: #{result}")
     return result
   end
 
   def replace_strings(line)
-    line.gsub(/"([^"\\]|\\.)*"/, "")
+    line.gsub(/"[^"]*"/, "")
   end
 
   def read_multiline_from_solver()
@@ -80,21 +104,23 @@ class SolverSession
     for_counting = ""
     @protocol.puts
     @protocol.puts("; BEGIN Multiline Solver Response:")
-    line = @z3outAndErr.gets
+    line = @solver.z3outAndErr.gets(chomp: true)
     result += line
-    for_counting += replace_strings(line)
+    for_counting = replace_strings(line)
     @protocol.puts("; #{line}")
     
     num_opening = for_counting.count("(")
     num_closing = for_counting.count(")")
-    while num_opening > num_closing do
-      line = @z3outAndErr.gets
-      result += line
-      for_counting += replace_strings(line)
-      @protocol.puts("; #{line}")
-
-      num_opening = for_counting.count("(")
-      num_closing = for_counting.count(")")
+    while num_opening > num_closing && line != nil do
+      line = @solver.z3outAndErr.gets(chomp: true)
+      if line
+        result += line
+        for_counting = replace_strings(line)
+        @protocol.puts("; #{line}")
+        
+        num_opening += for_counting.count("(")
+        num_closing += for_counting.count(")")
+      end
     end
     @protocol.puts("; END Multiline Solver Response")
     return result
@@ -133,150 +159,103 @@ class SolverSession
   def get_const_info(name)
     @consts[name]
   end
+
+  def parse_unsat_core(unsat_core)
+    @solver.parse_unsat_core(unsat_core, self)
+  end
+
+  def handleSolverError(progress, options, result)
+    @solver.handleSolverError(progress, self, options, result)
+  end
 end
 
-class Z3Solver
+class SolverFactory
+
+  attr_reader :z3path, :z3version
 
   def initialize(progress, z3path)
-    z3version = `#{z3path} --version`.chomp()
-    if $?.exitstatus == 0 then
+    @progress = progress
+    z3version = nil
+    exitstatus = nil
+    begin
+      z3version = `#{z3path} --version`.chomp()
+      exitstatus = $?.exitstatus
+    rescue Errno::ENOENT
+    end
+    if exitstatus == 0 && z3version != nil then
       progress.print_line "INFO: Using #{z3version} found in z3path=#{z3path}"
-      @z3in, @z3outAndErr, @z3thr = Open3.popen2e(z3path, '-in', '-smt2')
-      Process.detach(@z3thr.pid)
+      @z3path = z3path
+      @z3version = z3version
     else
       progress.print_line "WARN: could not find z3 in z3path=#{z3path.inspect}"
       `which z3`
       if $?.exitstatus == 0 then
         z3version = `z3 --version`.chomp()
         progress.print_line "However, #{z3version} is availlable on the PATH. Using this one."
-        @z3in, @z3outAndErr, @z3thr = Open3.popen2e('z3', '-in', '-smt2')
-        Process.detach(@z3thr.pid)
+        @z3path = 'z3'
+        @z3version = z3version
       else
-        raise RuntimeError.new("ERROR: unable to find Z3. Exiting! (Please provide its location in the config file using the key :z3path)")
+        raise RuntimeError.new("ERROR: unable to find Z3 solver. Exiting! (Please provide its location in the config file using the key :z3path)")
       end
     end
-    @z3in.sync = true
-
-    @sessionIdCounter = 0
   end
 
-  def close()
-    @z3in.close()
-    @z3outAndErr.close()
-    Thread.kill(@z3thr)
+  def new_solver()
+    Z3Solver.new(@progress, @z3path)
   end
 
-  def query(progress, options, &block)
+  def query(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])
+    @progress.print_line("calling solver (solver-log is written to #{options[:solverLog]})")
 
-    block.call(solver)
+    session = SolverSession.new(self, options[:solverLog])
+    block.call(session)
 
-    solver.to_solver(progress, "(check-sat)")
-    result = solver.from_solver(progress)
+    session.to_solver(@progress, "(check-sat)")
+    result = session.from_solver(@progress)
     explanation = true
-    if result.chomp == "sat"
+    if result == "sat"
         # model is not contradictory -> continue
-    elsif result.chomp == "unsat"
+    elsif result == "unsat"
         # model is contradictory -> add a message
 
-        solver.to_solver(progress, "(get-unsat-core)")
-        unsat_core = solver.from_solver(progress)
-        explanation = parse_unsat_core(solver, unsat_core)
+        session.to_solver(@progress, "(get-unsat-core)")
+        unsat_core = session.from_solver(@progress)
+        explanation = session.parse_unsat_core(unsat_core)
     else
-      handleSolverError(progress, solver, options, result)
+      session.handleSolverError(@progress, options, result)
     end
 
-    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!
-  def query_model(progress, options, &block)
+  def query_model(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])
+    @progress.print_line("calling solver (solver-log is written to #{options[:solverLog]})")
+    session = SolverSession.new(self, options[:solverLog])
 
-    block.call(solver)
-    
-    solver.to_solver(progress, "(check-sat)")
-    result = solver.from_solver(progress)
+    block.call(session)
+    session.to_solver(@progress, "(check-sat)")
+    result = session.from_solver(@progress)
     if result.chomp == "sat"
         # model is not contradictory -> extract model
         const_list = []
         const_info = {}
-        solver.for_each_const do |name, info|
+        session.for_each_const do |name, info|
           const_list << name
           const_info[name] = info
         end
-        solver.to_solver(progress, "(get-value (#{const_list.join(" ")}))")
-        model_str = solver.read_multiline_from_solver()
+        session.to_solver(@progress, "(get-value (#{const_list.join(" ")}))")
+        model_str = session.read_multiline_from_solver()
         model = {}
-        foreach_field_in_model_str(model_str, solver, const_info) do |varname, value, info|
+        Z3Solver.foreach_field_in_model_str(model_str, const_info) do |varname, value, info|
           unless info then
-            progress.print_line "WARN: no info availlable for varname=#{varname.inspect}, value=#{value.inspect}"
+            @progress.print_line "WARN: no info availlable for varname=#{varname.inspect}, value=#{value.inspect}"
           end
           xpath = info[:xpath]
           if model.has_key?(xpath) then
@@ -285,7 +264,7 @@ class Z3Solver
                 raise RuntimeError.new("inconsistent model: xpath #{xpath} should be a field, not a #{model[xpath][:type]}.")
               end
               unless value == "true" or value == "false" then
-                raise RuntimeError.new("inconsistent model value filled-value of #{xpath} should be a Bool, but was #{value.inspect}.")
+                raise RuntimeError.new("inconsistent model value: filled-value of #{xpath} should be a Bool, but was #{value.inspect}.")
               end
               if value == "true" then
                 model[xpath][:filled] = true
@@ -314,7 +293,7 @@ class Z3Solver
               end
             elsif varname.end_with?("-size") then
               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]}.")
+                raise RuntimeError.new("inconsistent model: xpath #{xpath} should be a list or a field, not a #{model[xpath][:type].inspect}.")
               end
               if model[xpath][:type] == :field then
                 model[xpath][:type] = :list
@@ -329,7 +308,7 @@ class Z3Solver
           else
             if varname.end_with?("-filled") then
               unless value == "true" or value == "false" then
-                raise RuntimeError.new("inconsistent model value filled-value of #{xpath} should be a Bool, but was #{value.inspect}.")
+                raise RuntimeError.new("inconsistent model value: filled-value of #{xpath} should be a Bool, but was #{value.inspect}.")
               end
               if value == "true" then
                 model[xpath] = { :type => :field, :filled => true }
@@ -341,7 +320,7 @@ class Z3Solver
               model[xpath] = {  :type => :field, :value => value }
             elsif varname.start_with?("struct-") && varname.end_with?("-exists") then
               unless value == "true" or value == "false" then
-                raise RuntimeError.new("inconsistent model value exists-value of struct #{xpath} should be a Bool, but was #{value.inspect}.")
+                raise RuntimeError.new("inconsistent model value: exists-value of struct #{xpath} should be a Bool, but was #{value.inspect}.")
               end
               model[xpath] = { :type => :struct, :exists => value }
             elsif varname.end_with?("-size") then
@@ -353,21 +332,27 @@ class Z3Solver
     elsif result.chomp == "unsat"
         # model is contradictory -> add a message
 
-        solver.to_solver(progress, "(get-unsat-core)")
-        unsat_core = solver.from_solver(progress)
-        solver.writeProtocolToFile(progress, options[:solverLog])
-        progress.print_line "Solver reported a contradiction! please see #{options[:solverLog]} for further information."
+        session.to_solver(@progress, "(get-unsat-core)")
+        unsat_core = session.from_solver(@progress)
+        session.writeProtocolToFile(@progress, options[:solverLog])
+        @progress.print_line "Solver reported a contradiction! please see #{options[:solverLog]} for further information."
         return nil
     else
-      handleSolverError(progress, solver, options, result)
+      session.handleSolverError(@progress, options, result)
     end
 
-    messages = []
-    solver.to_solver "(reset)"
-    solver.to_solver "(set-logic ALL)"
-    solver.to_solver "(set-option :produce-unsat-cores true)"
+    return nil
+  end
 
-    return messages
+  def convert_solver_value(type, datatype, value, xpath)
+    check_type(type, value, xpath)
+    if datatype == :date then
+      return (Time.at(0).to_date + Integer(value)).to_s
+    elsif datatype == :timestamp then
+      return Time.at(Integer(value)).to_s
+    else
+      return value
+    end
   end
 
   def check_type(type, value, xpath)
@@ -388,24 +373,119 @@ class Z3Solver
     end
   end
 
-  def convert_solver_value(type, datatype, value, xpath)
-    check_type(type, value, xpath)
-    if datatype == :date then
-      return (Time.at(0).to_date + Integer(value)).to_s
-    elsif datatype == :timestamp then
-      return Time.at(Integer(value)).to_s
+end
+
+class Z3Solver
+
+  attr_reader :z3in, :z3outAndErr
+
+  def initialize(progress, z3path)
+      @progress = progress
+      @z3in, @z3outAndErr, @z3thr = Open3.popen2e(z3path, '-in', '-smt2')
+      Process.detach(@z3thr.pid)
+      @z3in.sync = true
+      @sessionIdCounter = 0
+  end
+
+  def close()
+    begin
+      @z3in.close() unless @z3in.closed?
+    rescue Errno::EINVAL
+    end
+    begin
+      @z3outAndErr.close() unless @z3outAndErr.closed?
+    rescue Errno::EINVAL
+    end
+    Thread.kill(@z3thr)
+  end
+
+  def display_assertion(assertion, session)
+    if assertion =~ /validation_rule_(.*)_instance_(.*)/ then
+      return "Validation rule #{$1} of structure #{$2.gsub("_", "/")}"
     else
-      return value
+      info = session.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(unsat_core, session)
+    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, session)} (#{assertion})\n"
+    end
+    result += "\nviolate the following constraints\n"
+    list.filter{|a| !a.start_with?("doc-")}.each do |assertion|
+      result += "- #{display_assertion(assertion, session)} (#{assertion})\n"
+    end
+    return result
+  end
+
+  def self.find_matching_bracket(str)
+    i = 0
+    open = 0
+    in_str = false
+    while open <= 0 do
+      if str[i] == '(' and !in_str then
+        open += 1
+      elsif str[i] == '"' then
+        in_str = !in_str
+      end
+      i += 1    
+    end
+    while open > 0 do
+      if str[i] == '(' && !in_str then
+        open += 1
+      elsif str[i] == ')' && !in_str then
+        open -= 1
+      elsif str[i] == '"' then
+        in_str = !in_str
+      end
+      i += 1
     end
+    str[0,i]
   end
 
-  def foreach_field_in_model_str(str, solver, const_info, &block)
+  def self.foreach_field_in_model_str(str, const_info, &block)
     unless str =~ /^\((.*)\)$/m
       raise RuntimeError.new("could not parse model: #{str.inspect}")
     end
     str = $1
 
-    str.split("\n").each do |line|
+    while str.size() > 0 do
+      line = Z3Solver.find_matching_bracket(str)
+      str = str[line.size()..]
       unless line =~ /\(([^\ ]*)\ (.*)\)/
         raise RuntimeError.new("could not parse model line: #{line.inspect}")
       end
@@ -423,8 +503,8 @@ class Z3Solver
     return nil
   end
 
-  def handleSolverError(progress, solver, options, result)
-    solver.writeProtocolToFile(progress, options[:solverLog])
+  def handleSolverError(progress, session, options, result)
+    session.writeProtocolToFile(progress, options[:solverLog])
     raise RuntimeError.new("Solver Error: Solver returned '#{result}', for more information see #{options[:solverLog]}")
   end
 

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mbt-gen
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - FM-enthusiast
+autorequire:
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -41,6 +42,7 @@ licenses:
 metadata:
   bug_tracker_uri: https://codeberg.org/FM-enthusiast/MBT-gen/issues
   source_code_uri: https://codeberg.org/FM-enthusiast/MBT-gen
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -56,7 +58,8 @@ 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.6.7
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: test data generator for Model-based testing
 test_files: []