z3 0.0.20160427 → 0.0.20161008

data/spec/rounding_mode_sort_spec.rb

@@ -0,0 +1,13 @@
+module Z3
+  describe RoundingModeSort do
+    let(:sort) { RoundingModeSort.new }
+
+    it "to_s" do
+      expect(sort.to_s).to eq("RoundingMode")
+    end
+
+    it "inspect" do
+      expect(sort.inspect).to eq("RoundingModeSort")
+    end
+  end
+end

data/spec/set_expr_spec.rb

@@ -0,0 +1,61 @@
+module Z3
+  describe SetExpr do
+    let(:sort) { SetSort.new(IntSort.new) }
+    let(:a) { sort.var("a") }
+    let(:b) { sort.var("b") }
+    let(:c) { sort.var("c") }
+    let(:x) { Z3::Bool("x") }
+
+    # TODO: Formatting is dreadful
+    it "== and !=" do
+      expect([a == b, b != c]).to have_solution(
+        a => "store(const(false), 0, true)",
+        b => "store(const(false), 0, true)",
+        c => "const(false)",
+      )
+    end
+
+    # FIXME: This is not even real spec at this point, just a no-crash-spec
+    it "union" do
+      expect([
+        a.include?(1),
+        a.include?(2),
+        b.include?(2),
+        b.include?(3),
+        c == a.union(b),
+      ]).to have_solution(
+        a => "(declare-fun k! (Int) Bool)",
+        b => "(declare-fun k! (Int) Bool)",
+        c => "(declare-fun k! (Int) Bool)",
+      )
+    end
+
+    it "difference" do
+      expect([
+        a.include?(1),
+        a.include?(2),
+        b.include?(2),
+        b.include?(3),
+        c == a.difference(b),
+      ]).to have_solution(
+        a => "(declare-fun k! (Int) Bool)",
+        b => "(declare-fun k! (Int) Bool)",
+        c => "(declare-fun k! (Int) Bool)",
+      )
+    end
+
+    it "intersection" do
+      expect([
+        a.include?(1),
+        a.include?(2),
+        b.include?(2),
+        b.include?(3),
+        c == a.intersection(b),
+      ]).to have_solution(
+        a => "(declare-fun k! (Int) Bool)",
+        b => "(declare-fun k! (Int) Bool)",
+        c => "(declare-fun k! (Int) Bool)",
+      )
+    end
+  end
+end

data/spec/set_sort_spec.rb

@@ -0,0 +1,27 @@
+module Z3
+  describe SetSort do
+
+    let(:int_set)     { SetSort.new(IntSort.new) }
+    let(:real_set)    { SetSort.new(RealSort.new) }
+    let(:bool_set)    { SetSort.new(BoolSort.new) }
+    let(:bv32_set)    { SetSort.new(BitvecSort.new(32)) }
+    let(:int_set_set) { SetSort.new(SetSort.new(IntSort.new)) }
+
+    it "can instantiate variables" do
+      expect(int_set.var("a").inspect).to eq("Set(Int)<a>")
+      expect(real_set.var("a").inspect).to eq("Set(Real)<a>")
+      expect(bool_set.var("a").inspect).to eq("Set(Bool)<a>")
+      expect(bv32_set.var("a").inspect).to eq("Set(Bitvec(32))<a>")
+      expect(int_set_set.var("a").inspect).to eq("Set(Set(Int))<a>")
+    end
+
+    # These are pretty awful formattings
+    it "can instantiate full set" do
+      expect(int_set.Full.inspect).to eq("Set(Int)<const(true)>")
+    end
+
+    it "can instantiate empty set" do
+      expect(int_set.Empty.inspect).to eq("Set(Int)<const(false)>")
+    end
+  end
+end

data/spec/solver_spec.rb

@@ -1,33 +1,43 @@
 # Solver and Model specs are codependent, so half of functionality of each is tested in other class's tests
-describe Z3::Solver do
-  let(:solver) { Z3::Solver.new }
-  let(:a) { Z3.Int("a") }
-  let(:b) { Z3.Int("b") }
+module Z3
+  describe Solver do
+    let(:solver) { Solver.new }
+    let(:a) { Z3.Int("a") }
+    let(:b) { Z3.Int("b") }
 
-  it "basic functionality" do
-    solver.assert(a == b)
-    expect(solver.check).to eq(:sat)
-    solver.assert(a != b)
-    expect(solver.check).to eq(:unsat)
-  end
+    it "basic functionality" do
+      solver.assert(a == b)
+      expect(solver.check).to eq(:sat)
+      solver.assert(a != b)
+      expect(solver.check).to eq(:unsat)
+    end
 
-  it "push/pop" do
-    solver.assert(a == b)
-    solver.push
-    solver.assert(a != b)
-    expect(solver.check).to eq(:unsat)
-    solver.pop
-    expect(solver.check).to eq(:sat)
-  end
+    it "push/pop" do
+      solver.assert(a == b)
+      solver.push
+      solver.assert(a != b)
+      expect(solver.check).to eq(:unsat)
+      solver.pop
+      expect(solver.check).to eq(:sat)
+    end
+
+    it "#assertions" do
+      solver.assert a + b == 4
+      solver.assert b >= 2
+      solver.assert Z3.Or(a == 2, a == -2)
+      expect(solver.assertions).to be_same_as([
+        a + b == 4,
+        b >= 2,
+        (a == 2) | (a == -2),
+      ])
+    end
 
-  it "#assertions" do
-    solver.assert a + b == 4
-    solver.assert b >= 2
-    solver.assert Z3.Or(a == 2, a == -2)
-    expect(solver.assertions).to be_same_as([
-      a + b == 4,
-      b >= 2,
-      (a == 2) | (a == -2),
-    ])
+    it "#statistics" do
+      solver.assert a + b == 4
+      solver.assert b >= 2
+      solver.assert Z3.Or(a == 2, a == -2)
+      stats = solver.statistics
+      expect(stats.keys).to match_array(["rlimit count", "max memory", "memory", "num allocs"])
+    end
   end
 end

data/spec/sort_spec.rb

@@ -1,45 +1,47 @@
-describe Z3::Sort do
-  let(:bool_sort) { Z3::BoolSort.new }
-  let(:int_sort)  { Z3::IntSort.new }
-  let(:real_sort) { Z3::RealSort.new }
-  let(:bv8_sort)  { Z3::BitvecSort.new(8) }
-  let(:bv32_sort) { Z3::BitvecSort.new(32) }
+module Z3
+  describe Sort do
+    let(:bool_sort) { BoolSort.new }
+    let(:int_sort)  { IntSort.new }
+    let(:real_sort) { RealSort.new }
+    let(:bv8_sort)  { BitvecSort.new(8) }
+    let(:bv32_sort) { BitvecSort.new(32) }
 
-  let(:sorts) { [bool_sort, int_sort, real_sort, bv8_sort, bv32_sort] }
+    let(:sorts) { [bool_sort, int_sort, real_sort, bv8_sort, bv32_sort] }
 
-  it "can't instantiate Sort abstract superclass" do
-    expect{ Z3::Sort.new }.to raise_error(NoMethodError)
-  end
-
-  it "#to_s" do
-    expect(bool_sort.to_s).to eq("Bool")
-    expect( int_sort.to_s).to eq("Int")
-    expect(real_sort.to_s).to eq("Real")
-    expect( bv8_sort.to_s).to eq("Bitvec(8)")
-    expect(bv32_sort.to_s).to eq("Bitvec(32)")
-  end
+    it "can't instantiate Sort abstract superclass" do
+      expect{ Sort.new }.to raise_error(NoMethodError)
+    end
 
-  it "#inspect" do
-    expect(bool_sort.inspect).to eq("BoolSort")
-    expect( int_sort.inspect).to eq("IntSort")
-    expect(real_sort.inspect).to eq("RealSort")
-    expect( bv8_sort.inspect).to eq("BitvecSort(8)")
-    expect(bv32_sort.inspect).to eq("BitvecSort(32)")
-  end
+    it "#to_s" do
+      expect(bool_sort.to_s).to eq("Bool")
+      expect( int_sort.to_s).to eq("Int")
+      expect(real_sort.to_s).to eq("Real")
+      expect( bv8_sort.to_s).to eq("Bitvec(8)")
+      expect(bv32_sort.to_s).to eq("Bitvec(32)")
+    end
 
-  describe "==" do
-    it "all Sorts are value-objects" do
-      expect(bool_sort).to eq( Z3::BoolSort.new )
-      expect( int_sort).to eq( Z3::IntSort.new )
-      expect(real_sort).to eq( Z3::RealSort.new )
-      expect( bv8_sort).to eq( Z3::BitvecSort.new(8) )
-      expect(bv32_sort).to eq( Z3::BitvecSort.new(32) )
+    it "#inspect" do
+      expect(bool_sort.inspect).to eq("BoolSort")
+      expect( int_sort.inspect).to eq("IntSort")
+      expect(real_sort.inspect).to eq("RealSort")
+      expect( bv8_sort.inspect).to eq("BitvecSort(8)")
+      expect(bv32_sort.inspect).to eq("BitvecSort(32)")
     end
 
-    it "is == to itself and no other sort" do
-      sorts.each do |sort1|
-        sorts.each do |sort2|
-          expect(sort1 == sort2).to eq(sort1.to_s == sort2.to_s)
+    describe "==" do
+      it "all Sorts are value-objects" do
+        expect(bool_sort).to eq( BoolSort.new )
+        expect( int_sort).to eq( IntSort.new )
+        expect(real_sort).to eq( RealSort.new )
+        expect( bv8_sort).to eq( BitvecSort.new(8) )
+        expect(bv32_sort).to eq( BitvecSort.new(32) )
+      end
+
+      it "is == to itself and no other sort" do
+        sorts.each do |sort1|
+          sorts.each do |sort2|
+            expect(sort1 == sort2).to eq(sort1.to_s == sort2.to_s)
+          end
         end
       end
     end

data/spec/spec_helper.rb

@@ -2,7 +2,9 @@ require "pry"
 
 if ENV["COVERAGE"]
   require 'simplecov'
-  SimpleCov.start
+  SimpleCov.start do
+    add_filter "/spec/"
+  end
 end
 
 require_relative "../lib/z3"
@@ -36,7 +38,7 @@ end
 RSpec::Matchers.define :have_output do |expected|
   match do |file_name|
     executable_path = "#{__dir__}/../examples/#{file_name}"
-    actual = IO.popen(executable_path).read
+    actual = IO.popen("ruby -r./spec/coverage_helper #{executable_path}").read
     actual.gsub(/ *$/, "") == expected.gsub(/ *$/, "")
   end
 end
@@ -47,10 +49,26 @@ RSpec::Matchers.define :be_same_as do |expected|
   end
 end
 
+RSpec::Matchers.define :be_all_same do
+  match do |array|
+    array.uniq.size == 1
+  end
+end
+
+RSpec::Matchers.define :be_all_different do
+  match do |array|
+    array.uniq.size == array.size
+  end
+end
+
 RSpec::Matchers.define :stringify do |expected|
   match do |actual|
     actual.to_s == expected
   end
+
+  failure_message do
+    "Expected #{actual.inspect} to stringify to `#{expected}', got `#{actual.to_s}' instead"
+  end
 end
 
 RSpec::Matchers.define :have_solution do |expected|
@@ -76,3 +94,42 @@ RSpec::Matchers.define :have_solution do |expected|
     end
   end
 end
+
+RSpec::Matchers.define :have_solutions do |expected|
+  match do |asts|
+    solutions = get_all_solutions(asts)
+    solutions == expected
+  end
+
+  failure_message do |asts|
+    solutions = get_all_solutions(asts)
+    "expected #{asts.inspect} to have solutions:\n#{expected.map{|s| "* #{s.inspect}\n"}.join}, instead got:\n#{solutions.map{|s| "* #{s.inspect}\n"}.join}"
+  end
+
+  def get_all_solutions(asts)
+    vars = expected.map(&:keys)
+    raise "All expectations need same set of keys" unless vars.uniq.size == 1
+    vars = vars[0]
+    solver = setup_solver(asts)
+    solutions = []
+    while solver.check == :sat
+      model = solver.model
+      solution = Hash[vars.map{|v| [v, model.model_eval(v, true)] }]
+      solutions << solution
+      solver.assert Z3.Or(*solution.map{|var,val| var != val})
+      if solutions.size >= 10
+        binding.pry
+        raise "Too many solutions found, presumably infinite loop"
+      end
+    end
+    solutions
+  end
+
+  def setup_solver(asts)
+    Z3::Solver.new.tap do |solver|
+      asts.each do |ast|
+        solver.assert ast
+      end
+    end
+  end
+end

data/spec/tactic_spec.rb

@@ -0,0 +1,9 @@
+module Z3
+  describe Tactic do
+    it "constructors" do
+      expect(Tactic.fail).to be_a Tactic
+      expect(Tactic.fail_if_not_decided).to be_a Tactic
+      expect(Tactic.skip).to be_a Tactic
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: z3
 version: !ruby/object:Gem::Version
-  version: 0.0.20160427
+  version: 0.0.20161008
 platform: ruby
 authors:
 - Tomasz Wegrzanowski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-27 00:00:00.000000000 Z
+date: 2016-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -72,13 +86,16 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".rspec"
 - README.md
+- Rakefile
 - examples/algebra_problems
 - examples/basic_int_math
 - examples/basic_logic
 - examples/bit_tricks
 - examples/bridges
 - examples/bridges-1.txt
+- examples/circuit_problems
 - examples/clogic_puzzle
 - examples/four_hackers_puzzle
 - examples/geometry_problem
@@ -102,30 +119,47 @@ files:
 - lib/z3/context.rb
 - lib/z3/exception.rb
 - lib/z3/expr/arith_expr.rb
+- lib/z3/expr/array_expr.rb
 - lib/z3/expr/bitvec_expr.rb
 - lib/z3/expr/bool_expr.rb
 - lib/z3/expr/expr.rb
+- lib/z3/expr/float_expr.rb
 - lib/z3/expr/int_expr.rb
 - lib/z3/expr/real_expr.rb
+- lib/z3/expr/rounding_mode_expr.rb
+- lib/z3/expr/set_expr.rb
 - lib/z3/func_decl.rb
+- lib/z3/goal.rb
 - lib/z3/interface.rb
 - lib/z3/low_level.rb
 - lib/z3/low_level_auto.rb
 - lib/z3/model.rb
 - lib/z3/printer.rb
+- lib/z3/probe.rb
 - lib/z3/solver.rb
+- lib/z3/sort/array_sort.rb
 - lib/z3/sort/bitvec_sort.rb
 - lib/z3/sort/bool_sort.rb
+- lib/z3/sort/float_sort.rb
 - lib/z3/sort/int_sort.rb
 - lib/z3/sort/real_sort.rb
+- lib/z3/sort/rounding_mode_sort.rb
+- lib/z3/sort/set_sort.rb
 - lib/z3/sort/sort.rb
+- lib/z3/tactic.rb
 - lib/z3/very_low_level.rb
 - lib/z3/very_low_level_auto.rb
+- spec/array_expr_spec.rb
+- spec/array_sort_spec.rb
 - spec/bitvec_expr_spec.rb
 - spec/bitvec_sort_spec.rb
 - spec/bool_expr_spec.rb
 - spec/bool_sort_spec.rb
+- spec/coverage_helper.rb
 - spec/expr_spec.rb
+- spec/float_expr_spec.rb
+- spec/float_sort_spec.rb
+- spec/goal_spec.rb
 - spec/int_expr_spec.rb
 - spec/int_sort_spec.rb
 - spec/integration/algebra_problems_spec.rb
@@ -133,6 +167,7 @@ files:
 - spec/integration/basic_logic_spec.rb
 - spec/integration/bit_tricks_spec.rb
 - spec/integration/bridges_spec.rb
+- spec/integration/cicruit_problem_spec.rb
 - spec/integration/four_hackers_puzzle_spec.rb
 - spec/integration/geometry_problem_spec.rb
 - spec/integration/kakuro_spec.rb
@@ -147,11 +182,17 @@ files:
 - spec/integration/verbal_arithmetic_spec.rb
 - spec/model_spec.rb
 - spec/printer_spec.rb
+- spec/probe_spec.rb
 - spec/real_expr_spec.rb
 - spec/real_sort_spec.rb
+- spec/rounding_mode_expr_spec.rb
+- spec/rounding_mode_sort_spec.rb
+- spec/set_expr_spec.rb
+- spec/set_sort_spec.rb
 - spec/solver_spec.rb
 - spec/sort_spec.rb
 - spec/spec_helper.rb
+- spec/tactic_spec.rb
 - spec/z3_spec.rb
 homepage: https://github.com/taw/z3
 licenses:
@@ -174,9 +215,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements:
 - z3 library
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Z3 Constraint Solver
 test_files: []
-has_rdoc: