z3 0.0.20160427 → 0.0.20161008

data/lib/z3.rb

@@ -21,6 +21,10 @@ require_relative "z3/sort/int_sort"
 require_relative "z3/sort/real_sort"
 require_relative "z3/sort/bool_sort"
 require_relative "z3/sort/bitvec_sort"
+require_relative "z3/sort/float_sort"
+require_relative "z3/sort/rounding_mode_sort"
+require_relative "z3/sort/set_sort"
+require_relative "z3/sort/array_sort"
 
 # ASTs
 require_relative "z3/expr/expr"
@@ -29,6 +33,15 @@ require_relative "z3/expr/int_expr"
 require_relative "z3/expr/real_expr"
 require_relative "z3/expr/bool_expr"
 require_relative "z3/expr/bitvec_expr"
+require_relative "z3/expr/float_expr"
+require_relative "z3/expr/rounding_mode_expr"
+require_relative "z3/expr/set_expr"
+require_relative "z3/expr/array_expr"
+
+# Tactics, Probes, and Goals
+require_relative "z3/tactic"
+require_relative "z3/probe"
+require_relative "z3/goal"
 
 # Python-style interface
 require_relative "z3/interface"

data/spec/array_expr_spec.rb

@@ -0,0 +1,18 @@
+module Z3
+  describe ArrayExpr do
+    let(:sort) { ArraySort.new(IntSort.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(0), 0, 1)",
+        b => "store(const(0), 0, 1)",
+        c => "const(0)",
+      )
+    end
+  end
+end

data/spec/array_sort_spec.rb

@@ -0,0 +1,11 @@
+module Z3
+  describe ArraySort do
+    let(:int_int_array)   { ArraySort.new(IntSort.new, IntSort.new) }
+    let(:int_real_array)  { ArraySort.new(IntSort.new, RealSort.new) }
+
+    it "can instantiate variables" do
+      expect(int_int_array.var("a").inspect).to eq("Array(Int, Int)<a>")
+      expect(int_real_array.var("a").inspect).to eq("Array(Int, Real)<a>")
+    end
+  end
+end

data/spec/bitvec_expr_spec.rb

@@ -1,55 +1,207 @@
-describe Z3::BitvecExpr do
-  let(:a) { Z3::Bitvec("a", 8) }
-  let(:b) { Z3::Bitvec("b", 8) }
-  let(:c) { Z3::Bitvec("c", 8) }
-  let(:x) { Z3::Bool("x") }
-
-  it "==" do
-    expect([a == 2, b == -254, x == (a == b)]).to have_solution(x => true)
-    expect([a == 2, b == 2, x == (a == b)]).to have_solution(x => true)
-    expect([a == 2, b == 3, x == (a == b)]).to have_solution(x => false)
-  end
+module Z3
+  describe BitvecExpr do
+    let(:a) { Z3.Bitvec("a", 8) }
+    let(:b) { Z3.Bitvec("b", 8) }
+    let(:c) { Z3.Bitvec("c", 8) }
+    let(:d) { Z3.Bitvec("d", 12) }
+    let(:x) { Z3.Bool("x") }
 
-  it "!=" do
-    expect([a == 2, b == -254, x == (a != b)]).to have_solution(x => false)
-    expect([a == 2, b == 2, x == (a != b)]).to have_solution(x => false)
-    expect([a == 2, b == 3, x == (a != b)]).to have_solution(x => true)
-  end
+    it "==" do
+      expect([a == 2, b == -254, x == (a == b)]).to have_solution(x => true)
+      expect([a == 2, b == 2, x == (a == b)]).to have_solution(x => true)
+      expect([a == 2, b == 3, x == (a == b)]).to have_solution(x => false)
+    end
 
-  it "+" do
-    expect([a == 2, b == 40, c == (a + b)]).to have_solution(c => 42)
-    expect([a == 200, b == 40, c == (a + b)]).to have_solution(c => 240)
-    expect([a == -1, b == -1, c == (a + b)]).to have_solution(c => 254)
-  end
+    it "!=" do
+      expect([a == 2, b == -254, x == (a != b)]).to have_solution(x => false)
+      expect([a == 2, b == 2, x == (a != b)]).to have_solution(x => false)
+      expect([a == 2, b == 3, x == (a != b)]).to have_solution(x => true)
+    end
 
-  it "-" do
-    expect([a == 50, b == 8, c == (a - b)]).to have_solution(c => 42)
-    expect([a == 200, b == 40, c == (a - b)]).to have_solution(c => 160)
-    expect([a == 40, b == 200, c == (a - b)]).to have_solution(c => 96)
-  end
+    it "+" do
+      expect([a == 2, b == 40, c == (a + b)]).to have_solution(c => 42)
+      expect([a == 200, b == 40, c == (a + b)]).to have_solution(c => 240)
+      expect([a == -1, b == -1, c == (a + b)]).to have_solution(c => 254)
+    end
 
-  it "*" do
-    expect([a == 3, b == 40, c == (a * b)]).to have_solution(c => 120)
-    expect([a == 30, b == 42, c == (a * b)]).to have_solution(c => 236)
-  end
+    it "-" do
+      expect([a == 50, b == 8, c == (a - b)]).to have_solution(c => 42)
+      expect([a == 200, b == 40, c == (a - b)]).to have_solution(c => 160)
+      expect([a == 40, b == 200, c == (a - b)]).to have_solution(c => 96)
+    end
 
-  it "&" do
-    expect([a == 50, b == 27, c == (a & b)]).to have_solution(c => 18)
-  end
+    it "*" do
+      expect([a == 3, b == 40, c == (a * b)]).to have_solution(c => 120)
+      expect([a == 30, b == 42, c == (a * b)]).to have_solution(c => 236)
+    end
 
-  it "|" do
-    expect([a == 50, b == 27, c == (a | b)]).to have_solution(c => 59)
-  end
+    it "&" do
+      expect([a == 50, b == 27, c == (a & b)]).to have_solution(c => 18)
+    end
 
-  it "^" do
-    expect([a == 50, b == 27, c == (a ^ b)]).to have_solution(c => 41)
-  end
+    it "|" do
+      expect([a == 50, b == 27, c == (a | b)]).to have_solution(c => 59)
+    end
 
-  it "unary -" do
-    expect([a == 50, b == -a]).to have_solution(b => 206)
-  end
+    it "^" do
+      expect([a == 50, b == 27, c == (a ^ b)]).to have_solution(c => 41)
+    end
+
+    it "xnor" do
+      expect([a == 50, b == 27, c == a.xnor(b)]).to have_solution(c => 214)
+    end
+
+    it "nand" do
+      expect([a == 50, b == 27, c == a.nand(b)]).to have_solution(c => 237)
+    end
+
+    it "nor" do
+      expect([a == 50, b == 27, c == a.nor(b)]).to have_solution(c => 196)
+    end
+
+    it "unary -" do
+      expect([a == 50, b == -a]).to have_solution(b => 206)
+    end
+
+    it "~" do
+      expect([a == 50, b == ~a]).to have_solution(b => 205)
+    end
+
+    it ">> (sign-dependent)" do
+      expect([a == 234, b == 2, c == a.unsigned_rshift(b)]).to have_solution(c => 58)
+      expect([a == 234, b == 2, c == a.signed_rshift(b)]).to have_solution(c => 250)
+      expect{ a.rshift(b) }.to raise_error(Z3::Exception)
+      expect{ a >> b }.to raise_error(Z3::Exception)
+    end
+
+    it "<< (sign-independent)" do
+      expect([a == 234, b == 2, c == a.signed_lshift(b)]).to have_solution(c => 168)
+      expect([a == 234, b == 2, c == a.unsigned_lshift(b)]).to have_solution(c => 168)
+      expect([a == 234, b == 2, c == a.lshift(b)]).to have_solution(c => 168)
+      expect([a == 234, b == 2, c == (a << b)]).to have_solution(c => 168)
+    end
+
+    it ">" do
+      expect{ a > b }.to raise_error(Z3::Exception)
+      expect([a == 100, b ==  20, x == a.unsigned_gt(b)]).to have_solution(x => true)
+      expect([a == 100, b == 100, x == a.unsigned_gt(b)]).to have_solution(x => false)
+      expect([a == 100, b == 120, x == a.unsigned_gt(b)]).to have_solution(x => false)
+      expect([a == 100, b == 200, x == a.unsigned_gt(b)]).to have_solution(x => false)
+      expect([a == 100, b ==  20, x == a.signed_gt(b)]).to have_solution(x => true)
+      expect([a == 100, b == 100, x == a.signed_gt(b)]).to have_solution(x => false)
+      expect([a == 100, b == 120, x == a.signed_gt(b)]).to have_solution(x => false)
+      expect([a == 100, b == 200, x == a.signed_gt(b)]).to have_solution(x => true)
+    end
+
+    it ">=" do
+      expect{ a >= b }.to raise_error(Z3::Exception)
+      expect([a == 100, b ==  20, x == a.unsigned_ge(b)]).to have_solution(x => true)
+      expect([a == 100, b == 100, x == a.unsigned_ge(b)]).to have_solution(x => true)
+      expect([a == 100, b == 120, x == a.unsigned_ge(b)]).to have_solution(x => false)
+      expect([a == 100, b == 200, x == a.unsigned_ge(b)]).to have_solution(x => false)
+      expect([a == 100, b ==  20, x == a.signed_ge(b)]).to have_solution(x => true)
+      expect([a == 100, b == 100, x == a.signed_ge(b)]).to have_solution(x => true)
+      expect([a == 100, b == 120, x == a.signed_ge(b)]).to have_solution(x => false)
+      expect([a == 100, b == 200, x == a.signed_ge(b)]).to have_solution(x => true)
+    end
+
+    it "<" do
+      expect{ a < b }.to raise_error(Z3::Exception)
+      expect([a == 100, b ==  20, x == a.unsigned_lt(b)]).to have_solution(x => false)
+      expect([a == 100, b == 100, x == a.unsigned_lt(b)]).to have_solution(x => false)
+      expect([a == 100, b == 120, x == a.unsigned_lt(b)]).to have_solution(x =>  true)
+      expect([a == 100, b == 200, x == a.unsigned_lt(b)]).to have_solution(x =>  true)
+      expect([a == 100, b ==  20, x == a.signed_lt(b)]).to have_solution(x => false)
+      expect([a == 100, b == 100, x == a.signed_lt(b)]).to have_solution(x => false)
+      expect([a == 100, b == 120, x == a.signed_lt(b)]).to have_solution(x =>  true)
+      expect([a == 100, b == 200, x == a.signed_lt(b)]).to have_solution(x => false)
+    end
+
+    it "<=" do
+      expect{ a <= b }.to raise_error(Z3::Exception)
+      expect([a == 100, b ==  20, x == a.unsigned_le(b)]).to have_solution(x => false)
+      expect([a == 100, b == 100, x == a.unsigned_le(b)]).to have_solution(x =>  true)
+      expect([a == 100, b == 120, x == a.unsigned_le(b)]).to have_solution(x =>  true)
+      expect([a == 100, b == 200, x == a.unsigned_le(b)]).to have_solution(x =>  true)
+      expect([a == 100, b ==  20, x == a.signed_le(b)]).to have_solution(x => false)
+      expect([a == 100, b == 100, x == a.signed_le(b)]).to have_solution(x =>  true)
+      expect([a == 100, b == 120, x == a.signed_le(b)]).to have_solution(x =>  true)
+      expect([a == 100, b == 200, x == a.signed_le(b)]).to have_solution(x => false)
+    end
+
+    it "signed_add_no_overflow?" do
+      expect([a ==  100, b ==  100, x == a.signed_add_no_overflow?(b)]).to have_solution(x => false)
+      expect([a ==   50, b ==   50, x == a.signed_add_no_overflow?(b)]).to have_solution(x => true)
+      expect([a ==  -50, b ==  -50, x == a.signed_add_no_overflow?(b)]).to have_solution(x => true)
+      expect([a == -100, b == -100, x == a.signed_add_no_overflow?(b)]).to have_solution(x => true)
+    end
+
+    it "unsigned_add_no_overflow?" do
+      expect([a ==  100, b ==  100, x == a.unsigned_add_no_overflow?(b)]).to have_solution(x => true)
+      expect([a ==   50, b ==   50, x == a.unsigned_add_no_overflow?(b)]).to have_solution(x => true)
+      expect([a ==  -50, b ==  -50, x == a.unsigned_add_no_overflow?(b)]).to have_solution(x => false)
+      expect([a == -100, b == -100, x == a.unsigned_add_no_overflow?(b)]).to have_solution(x => false)
+    end
+
+    # Inherently signed, unsigned add can't underflow
+    it "signed_add_no_underflow?" do
+      expect([a ==  100, b ==  100, x == a.signed_add_no_underflow?(b)]).to have_solution(x => true)
+      expect([a ==   50, b ==   50, x == a.signed_add_no_underflow?(b)]).to have_solution(x => true)
+      expect([a ==  -50, b ==  -50, x == a.signed_add_no_underflow?(b)]).to have_solution(x => true)
+      expect([a == -100, b == -100, x == a.signed_add_no_underflow?(b)]).to have_solution(x => false)
+    end
+
+    # Inherently signed, there is no signed neg
+    it "signed_neg_no_overflow?" do
+      expect([a ==  100, x == a.signed_neg_no_overflow?]).to have_solution(x => true)
+      expect([a == -100, x == a.signed_neg_no_overflow?]).to have_solution(x => true)
+      expect([a ==    0, x == a.signed_neg_no_overflow?]).to have_solution(x => true)
+      expect([a ==  127, x == a.signed_neg_no_overflow?]).to have_solution(x => true)
+      expect([a == -128, x == a.signed_neg_no_overflow?]).to have_solution(x => false)
+    end
+
+    # Unsigned div can't overflow, and signed div can only overflow for one value
+    it "signed_div_no_overflow?" do
+      expect([a ==  -128, b == -1, x == a.signed_div_no_overflow?(b)]).to have_solution(x => false)
+      expect([a ==  -128, b == -2, x == a.signed_div_no_overflow?(b)]).to have_solution(x => true)
+      expect([a ==   127, b ==  1, x == a.signed_div_no_overflow?(b)]).to have_solution(x => true)
+    end
+
+    ## This API is broken, z3 returns unevaluated bvsmul_noovfl(10, 10) instead of actual answer
+
+    # it "signed_mul_no_overflow?" do
+    #   expect([a ==   10, b ==   10, x == a.signed_mul_no_overflow?(b)]).to have_solution(x => true)
+    #   expect([a ==   20, b ==   10, x == a.signed_mul_no_overflow?(b)]).to have_solution(x => false)
+    #   expect([a ==   20, b ==   20, x == a.signed_mul_no_overflow?(b)]).to have_solution(x => false)
+    #   expect([a ==  -10, b ==  -10, x == a.signed_mul_no_overflow?(b)]).to have_solution(x => true)
+    # end
+    #
+    # it "unsigned_mul_no_overflow?" do
+    #   expect([a ==   10, b ==   10, x == a.unsigned_mul_no_overflow?(b)]).to have_solution(x => true)
+    #   expect([a ==   20, b ==   10, x == a.unsigned_mul_no_overflow?(b)]).to have_solution(x => true)
+    #   expect([a ==   20, b ==   20, x == a.unsigned_mul_no_overflow?(b)]).to have_solution(x => false)
+    #   expect([a ==  -10, b ==  -10, x == a.unsigned_mul_no_overflow?(b)]).to have_solution(x => false)
+    # end
+    #
+    # # Inherently signed, unsigned can't underflow
+    # it "signed_mul_no_underflow?" do
+    #   expect([a ==  -10, b ==  -10, x == a.signed_mul_no_underflow?(b)]).to have_solution(x => true)
+    #   expect([a ==  -20, b ==  -20, x == a.signed_mul_no_underflow?(b)]).to have_solution(x => true)
+    #   expect([a ==  -20, b ==   20, x == a.signed_mul_no_underflow?(b)]).to have_solution(x => false)
+    # end
+
+    it "zero_ext / sign_ext" do
+      expect([a ==  100, d ==  a.zero_ext(4)]).to have_solution(d => 100)
+      expect([a == -100, d ==  a.zero_ext(4)]).to have_solution(d => 2**8-100)
+      expect([a ==  100, d ==  a.sign_ext(4)]).to have_solution(d => 100)
+      expect([a == -100, d ==  a.sign_ext(4)]).to have_solution(d => 2**12-100)
+    end
 
-  it "~" do
-    expect([a == 50, b == ~a]).to have_solution(b => 205)
+    it "rotate_left / rotate_right" do
+      expect([a == 0b0101_0110, b == a.rotate_left(1)]).to have_solution(b => 0b101_0110_0)
+      expect([a == 0b0101_0110, b == a.rotate_left(4)]).to have_solution(b => 0b0110_0101)
+      expect([a == 0b0101_0110, b == a.rotate_right(1)]).to have_solution(b => 0b0_0101_011)
+      expect([a == 0b0101_0110, b == a.rotate_right(4)]).to have_solution(b => 0b0110_0101)
+    end
   end
 end

data/spec/bitvec_sort_spec.rb

@@ -1,34 +1,36 @@
-describe Z3::BitvecSort do
-  let(:bv3) { Z3::BitvecSort.new(3) }
-  let(:bv8) { Z3::BitvecSort.new(8) }
-  let(:bv32) { Z3::BitvecSort.new(32) }
+module Z3
+  describe BitvecSort do
+    let(:bv3) { BitvecSort.new(3) }
+    let(:bv8) { BitvecSort.new(8) }
+    let(:bv32) { BitvecSort.new(32) }
 
-  it "can instantiate constants - 32 bit" do
-    expect(bv32.from_const(0).inspect).to eq("Bitvec(32)<0>")
-    expect(bv32.from_const(42).inspect).to eq("Bitvec(32)<42>")
-    expect(bv32.from_const(0x1234_5678_9abc).inspect).to eq("Bitvec(32)<1450744508>")
-    expect(bv32.from_const(-0x1234_5678_9abc).inspect).to eq("Bitvec(32)<2844222788>")
-  end
+    it "can instantiate constants - 32 bit" do
+      expect(bv32.from_const(0).inspect).to eq("Bitvec(32)<0>")
+      expect(bv32.from_const(42).inspect).to eq("Bitvec(32)<42>")
+      expect(bv32.from_const(0x1234_5678_9abc).inspect).to eq("Bitvec(32)<1450744508>")
+      expect(bv32.from_const(-0x1234_5678_9abc).inspect).to eq("Bitvec(32)<2844222788>")
+    end
 
-  it "can instantiate constants - 8 bit" do
-    expect(bv8.from_const(0).inspect).to eq("Bitvec(8)<0>")
-    expect(bv8.from_const(42).inspect).to eq("Bitvec(8)<42>")
-    expect(bv8.from_const(0x1234_5678_9abc).inspect).to eq("Bitvec(8)<188>")
-    expect(bv8.from_const(-0x1234_5678_9abc).inspect).to eq("Bitvec(8)<68>")
-  end
+    it "can instantiate constants - 8 bit" do
+      expect(bv8.from_const(0).inspect).to eq("Bitvec(8)<0>")
+      expect(bv8.from_const(42).inspect).to eq("Bitvec(8)<42>")
+      expect(bv8.from_const(0x1234_5678_9abc).inspect).to eq("Bitvec(8)<188>")
+      expect(bv8.from_const(-0x1234_5678_9abc).inspect).to eq("Bitvec(8)<68>")
+    end
 
-  it "can instantiate constants - 3 bit" do
-    expect(bv3.from_const(-1).inspect).to eq("Bitvec(3)<7>")
-  end
+    it "can instantiate constants - 3 bit" do
+      expect(bv3.from_const(-1).inspect).to eq("Bitvec(3)<7>")
+    end
 
-  it "raisesbv32 exception when trying to convert constants of wrong type" do
-    expect{ bv32.from_const(true) }.to raise_error(Z3::Exception)
-    expect{ bv32.from_const(false) }.to raise_error(Z3::Exception)
-    expect{ bv32.from_const(0.0) }.to raise_error(Z3::Exception)
-  end
+    it "raisesbv32 exception when trying to convert constants of wrong type" do
+      expect{ bv32.from_const(true) }.to raise_error(Z3::Exception)
+      expect{ bv32.from_const(false) }.to raise_error(Z3::Exception)
+      expect{ bv32.from_const(0.0) }.to raise_error(Z3::Exception)
+    end
 
-  it "can instantiate variables" do
-    expect(Z3.Bitvec("a", 8).inspect).to eq("Bitvec(8)<a>")
-    expect(Z3.Bitvec("a", 32).inspect).to eq("Bitvec(32)<a>")
+    it "can instantiate variables" do
+      expect(Z3.Bitvec("a", 8).inspect).to eq("Bitvec(8)<a>")
+      expect(Z3.Bitvec("a", 32).inspect).to eq("Bitvec(32)<a>")
+    end
   end
 end

data/spec/bool_expr_spec.rb

@@ -1,65 +1,67 @@
-describe Z3::BoolExpr do
-  let(:a) { Z3::Bool("a") }
-  let(:b) { Z3::Bool("b") }
-  let(:c) { Z3::Bool("c") }
-  let(:x) { Z3::Int("x") }
+module Z3
+  describe BoolExpr do
+    let(:a) { Z3.Bool("a") }
+    let(:b) { Z3.Bool("b") }
+    let(:c) { Z3.Bool("c") }
+    let(:x) { Z3.Int("x") }
 
-  it "&" do
-    expect([a ==  true, b ==  true, c == (a & b)]).to have_solution(c =>  true)
-    expect([a ==  true, b == false, c == (a & b)]).to have_solution(c => false)
-    expect([a == false, b ==  true, c == (a & b)]).to have_solution(c => false)
-    expect([a == false, b == false, c == (a & b)]).to have_solution(c => false)
-  end
+    it "&" do
+      expect([a ==  true, b ==  true, c == (a & b)]).to have_solution(c =>  true)
+      expect([a ==  true, b == false, c == (a & b)]).to have_solution(c => false)
+      expect([a == false, b ==  true, c == (a & b)]).to have_solution(c => false)
+      expect([a == false, b == false, c == (a & b)]).to have_solution(c => false)
+    end
 
-  it "|" do
-    expect([a ==  true, b ==  true, c == (a | b)]).to have_solution(c =>  true)
-    expect([a ==  true, b == false, c == (a | b)]).to have_solution(c =>  true)
-    expect([a == false, b ==  true, c == (a | b)]).to have_solution(c =>  true)
-    expect([a == false, b == false, c == (a | b)]).to have_solution(c => false)
-  end
+    it "|" do
+      expect([a ==  true, b ==  true, c == (a | b)]).to have_solution(c =>  true)
+      expect([a ==  true, b == false, c == (a | b)]).to have_solution(c =>  true)
+      expect([a == false, b ==  true, c == (a | b)]).to have_solution(c =>  true)
+      expect([a == false, b == false, c == (a | b)]).to have_solution(c => false)
+    end
 
-  it "^" do
-    expect([a ==  true, b ==  true, c == (a ^ b)]).to have_solution(c => false)
-    expect([a ==  true, b == false, c == (a ^ b)]).to have_solution(c =>  true)
-    expect([a == false, b ==  true, c == (a ^ b)]).to have_solution(c =>  true)
-    expect([a == false, b == false, c == (a ^ b)]).to have_solution(c => false)
-  end
+    it "^" do
+      expect([a ==  true, b ==  true, c == (a ^ b)]).to have_solution(c => false)
+      expect([a ==  true, b == false, c == (a ^ b)]).to have_solution(c =>  true)
+      expect([a == false, b ==  true, c == (a ^ b)]).to have_solution(c =>  true)
+      expect([a == false, b == false, c == (a ^ b)]).to have_solution(c => false)
+    end
 
-  it "!=" do
-    expect([a ==  true, b ==  true, c == (a != b)]).to have_solution(c => false)
-    expect([a ==  true, b == false, c == (a != b)]).to have_solution(c =>  true)
-    expect([a == false, b ==  true, c == (a != b)]).to have_solution(c =>  true)
-    expect([a == false, b == false, c == (a != b)]).to have_solution(c => false)
-  end
+    it "!=" do
+      expect([a ==  true, b ==  true, c == (a != b)]).to have_solution(c => false)
+      expect([a ==  true, b == false, c == (a != b)]).to have_solution(c =>  true)
+      expect([a == false, b ==  true, c == (a != b)]).to have_solution(c =>  true)
+      expect([a == false, b == false, c == (a != b)]).to have_solution(c => false)
+    end
 
-  it "implies" do
-    expect([a ==  true, b ==  true, c == a.implies(b)]).to have_solution(c =>  true)
-    expect([a ==  true, b == false, c == a.implies(b)]).to have_solution(c => false)
-    expect([a == false, b ==  true, c == a.implies(b)]).to have_solution(c =>  true)
-    expect([a == false, b == false, c == a.implies(b)]).to have_solution(c =>  true)
-  end
+    it "implies" do
+      expect([a ==  true, b ==  true, c == a.implies(b)]).to have_solution(c =>  true)
+      expect([a ==  true, b == false, c == a.implies(b)]).to have_solution(c => false)
+      expect([a == false, b ==  true, c == a.implies(b)]).to have_solution(c =>  true)
+      expect([a == false, b == false, c == a.implies(b)]).to have_solution(c =>  true)
+    end
 
-  it "iff" do
-    expect([a ==  true, b ==  true, c == a.iff(b)]).to have_solution(c =>  true)
-    expect([a ==  true, b == false, c == a.iff(b)]).to have_solution(c => false)
-    expect([a == false, b ==  true, c == a.iff(b)]).to have_solution(c => false)
-    expect([a == false, b == false, c == a.iff(b)]).to have_solution(c =>  true)
-  end
+    it "iff" do
+      expect([a ==  true, b ==  true, c == a.iff(b)]).to have_solution(c =>  true)
+      expect([a ==  true, b == false, c == a.iff(b)]).to have_solution(c => false)
+      expect([a == false, b ==  true, c == a.iff(b)]).to have_solution(c => false)
+      expect([a == false, b == false, c == a.iff(b)]).to have_solution(c =>  true)
+    end
 
-  it "==" do
-    expect([a ==  true, b ==  true, c == (a == b)]).to have_solution(c =>  true)
-    expect([a ==  true, b == false, c == (a == b)]).to have_solution(c => false)
-    expect([a == false, b ==  true, c == (a == b)]).to have_solution(c => false)
-    expect([a == false, b == false, c == (a == b)]).to have_solution(c =>  true)
-  end
+    it "==" do
+      expect([a ==  true, b ==  true, c == (a == b)]).to have_solution(c =>  true)
+      expect([a ==  true, b == false, c == (a == b)]).to have_solution(c => false)
+      expect([a == false, b ==  true, c == (a == b)]).to have_solution(c => false)
+      expect([a == false, b == false, c == (a == b)]).to have_solution(c =>  true)
+    end
 
-  it "~" do
-    expect([a ==  true, b == ~a]).to have_solution(b => false)
-    expect([a == false, b == ~a]).to have_solution(b =>  true)
-   end
+    it "~" do
+      expect([a ==  true, b == ~a]).to have_solution(b => false)
+      expect([a == false, b == ~a]).to have_solution(b =>  true)
+     end
 
-   it "if then else" do
-     expect([a ==  true, x == a.ite(2, 3)]).to have_solution(x => 2)
-     expect([a == false, x == a.ite(2, 3)]).to have_solution(x => 3)
-   end
+     it "if then else" do
+       expect([a ==  true, x == a.ite(2, 3)]).to have_solution(x => 2)
+       expect([a == false, x == a.ite(2, 3)]).to have_solution(x => 3)
+     end
+  end
 end

data/spec/bool_sort_spec.rb

@@ -1,20 +1,22 @@
-describe Z3::BoolSort do
-  it "can instantiate constants" do
-    expect(subject.from_const(true).inspect).to eq("Bool<true>")
-    expect(subject.from_const(false).inspect).to eq("Bool<false>")
-  end
+module Z3
+  describe BoolSort do
+    it "can instantiate constants" do
+      expect(subject.from_const(true).inspect).to eq("Bool<true>")
+      expect(subject.from_const(false).inspect).to eq("Bool<false>")
+    end
 
-  it "raises exception when trying to convert constants of wrong type" do
-    expect{ subject.from_const(0) }.to raise_error(Z3::Exception)
-    expect{ subject.from_const(0.0) }.to raise_error(Z3::Exception)
-  end
+    it "raises exception when trying to convert constants of wrong type" do
+      expect{ subject.from_const(0) }.to raise_error(Z3::Exception)
+      expect{ subject.from_const(0.0) }.to raise_error(Z3::Exception)
+    end
 
-  it "interface constructors" do
-    expect(Z3.True.inspect).to eq("Bool<true>")
-    expect(Z3.False.inspect).to eq("Bool<false>")
-  end
+    it "interface constructors" do
+      expect(Z3.True.inspect).to eq("Bool<true>")
+      expect(Z3.False.inspect).to eq("Bool<false>")
+    end
 
-  it "can instantiate variables" do
-    expect(Z3.Bool("a").inspect).to eq("Bool<a>")
+    it "can instantiate variables" do
+      expect(Z3.Bool("a").inspect).to eq("Bool<a>")
+    end
   end
 end

data/spec/coverage_helper.rb

@@ -0,0 +1,11 @@
+if ENV["COVERAGE"]
+  require "simplecov"
+  SimpleCov.command_name "#{File.basename($0)}"
+  SimpleCov.start do
+    add_filter "/spec/"
+  end
+  SimpleCov.at_exit do
+    # Remove verbosity
+    $stderr = open("/dev/null", "w")
+  end
+end