z3 0.0.20160427 → 0.0.20161008

data/spec/expr_spec.rb

@@ -1,175 +1,179 @@
-describe Z3::Expr do
-  let(:a) { Z3.Int("a") }
-  let(:b) { Z3.Int("b") }
-  let(:c) { Z3.Bool("c") }
-  let(:d) { Z3.Bool("d") }
-  let(:e) { Z3.Real("e") }
-  let(:f) { Z3.Real("f") }
-
-  it "#sort returns Sort object" do
-    expect(a.sort).to eq(Z3::IntSort.new)
-    expect(c.sort).to eq(Z3::BoolSort.new)
-    expect(e.sort).to eq(Z3::RealSort.new)
-  end
-
-  it "#to_s" do
-    expect(a.to_s).to eq("a")
-  end
-
-  it "#inspect" do
-    expect(a.inspect).to eq("Int<a>")
-    expect((e+f).inspect).to eq("Real<(+ e f)>")
-  end
-
-  describe "#~" do
-    it "allows negating boolean variables" do
-      expect((~c).to_s).to eq("(not c)")
+# TODO: This spec doesn't reflect current functionality all that well
+
+module Z3
+  describe Expr do
+    let(:a) { Z3.Int("a") }
+    let(:b) { Z3.Int("b") }
+    let(:c) { Z3.Bool("c") }
+    let(:d) { Z3.Bool("d") }
+    let(:e) { Z3.Real("e") }
+    let(:f) { Z3.Real("f") }
+
+    it "#sort returns Sort object" do
+      expect(a.sort).to eq(IntSort.new)
+      expect(c.sort).to eq(BoolSort.new)
+      expect(e.sort).to eq(RealSort.new)
     end
 
-    it "raises exception if type cast is not possible" do
-      expect{~a}.to raise_error(NoMethodError)
-      expect{~e}.to raise_error(NoMethodError)
+    it "#to_s" do
+      expect(a.sexpr).to eq("a")
     end
-  end
 
-  describe "#&" do
-    it "allows and of boolean variables" do
-      expect((c & d).to_s).to eq("(and c d)")
+    it "#inspect" do
+      expect(a.inspect).to eq("Int<a>")
+      expect((e+f).inspect).to eq("Real<e + f>")
     end
 
-    it "raises exception if type cast is not possible" do
-      expect{a&b}.to raise_error(NoMethodError)
-      expect{e&f}.to raise_error(NoMethodError)
-      expect{a&c}.to raise_error(NoMethodError)
-      expect{e&c}.to raise_error(NoMethodError)
-      expect{c&a}.to raise_error(ArgumentError)
-      expect{c&e}.to raise_error(ArgumentError)
-    end
-  end
+    describe "#~" do
+      it "allows negating boolean variables" do
+        expect((~c).sexpr).to eq("(not c)")
+      end
 
-  describe "#|" do
-    it "allows or of boolean variables" do
-      expect((c | d).to_s).to eq("(or c d)")
+      it "raises exception if type cast is not possible" do
+        expect{~a}.to raise_error(NoMethodError)
+        expect{~e}.to raise_error(NoMethodError)
+      end
     end
 
-    it "raises exception if type cast is not possible" do
-      expect{a|b}.to raise_error(NoMethodError)
-      expect{e|f}.to raise_error(NoMethodError)
-      expect{a|c}.to raise_error(NoMethodError)
-      expect{e|c}.to raise_error(NoMethodError)
-      expect{c|a}.to raise_error(ArgumentError)
-      expect{c|e}.to raise_error(ArgumentError)
-    end
-  end
+    describe "#&" do
+      it "allows and of boolean variables" do
+        expect((c & d).sexpr).to eq("(and c d)")
+      end
 
-  %W[+ - * <= < >= >].each do |op|
-    describe "#{op} arithmetic operator" do
-      it "allows + of int or real variables" do
-        expect((a.send op, b).to_s).to eq "(#{op} a b)"
-        expect((e.send op, f).to_s).to eq "(#{op} e f)"
+      it "raises exception if type cast is not possible" do
+        expect{a&b}.to raise_error(NoMethodError)
+        expect{e&f}.to raise_error(NoMethodError)
+        expect{a&c}.to raise_error(NoMethodError)
+        expect{e&c}.to raise_error(NoMethodError)
+        expect{c&a}.to raise_error(ArgumentError)
+        expect{c&e}.to raise_error(ArgumentError)
       end
+    end
 
-      it "casts to correct type if possible" do
-        expect((a.send op, e).to_s).to eq "(#{op} (to_real a) e)"
-        expect((e.send op, a).to_s).to eq "(#{op} e (to_real a))"
-        expect((a.send op, 42).to_s).to eq "(#{op} a 42)"
-        expect((42.send op, a).to_s).to eq "(#{op} 42 a)"
-        expect((a.send op, 42.5).to_s).to eq "(#{op} (to_real a) (/ 85.0 2.0))"
-        expect((42.5.send op, a).to_s).to eq "(#{op} (/ 85.0 2.0) (to_real a))"
-        expect((e.send op, 42).to_s).to eq "(#{op} e 42.0)"
-        expect((42.send op, e).to_s).to eq "(#{op} 42.0 e)"
-        expect((e.send op, 42.5).to_s).to eq "(#{op} e (/ 85.0 2.0))"
-        expect((42.5.send op, e).to_s).to eq "(#{op} (/ 85.0 2.0) e)"
+    describe "#|" do
+      it "allows or of boolean variables" do
+        expect((c | d).sexpr).to eq("(or c d)")
       end
 
       it "raises exception if type cast is not possible" do
-        # Int/Real has #>= #+ etc. but they don't like these arguments
-        expect{a.send op, c}.to raise_error(ArgumentError)
-        expect{e.send op, c}.to raise_error(ArgumentError)
-        expect{a.send op, true}.to raise_error(ArgumentError)
-        expect{a.send op, false}.to raise_error(ArgumentError)
-        expect{e.send op, true}.to raise_error(ArgumentError)
-        expect{e.send op, false}.to raise_error(ArgumentError)
-
-        # Bool doesn't have #>= #+ etc.
-        expect{c.send op, a}.to raise_error(NoMethodError)
-        expect{c.send op, d}.to raise_error(NoMethodError)
-        expect{c.send op, e}.to raise_error(NoMethodError)
-        expect{c.send op, true}.to raise_error(NoMethodError)
-        expect{c.send op, false}.to raise_error(NoMethodError)
+        expect{a|b}.to raise_error(NoMethodError)
+        expect{e|f}.to raise_error(NoMethodError)
+        expect{a|c}.to raise_error(NoMethodError)
+        expect{e|c}.to raise_error(NoMethodError)
+        expect{c|a}.to raise_error(ArgumentError)
+        expect{c|e}.to raise_error(ArgumentError)
       end
     end
-  end
 
-  describe "#==" do
-    it "allows == of variables of same sort" do
-      expect((a == b).to_s).to eq "(= a b)"
-      expect((c == d).to_s).to eq "(= c d)"
-      expect((e == f).to_s).to eq "(= e f)"
+    %W[+ - * <= < >= >].each do |op|
+      describe "#{op} arithmetic operator" do
+        it "allows + of int or real variables" do
+          expect((a.send op, b).sexpr).to eq "(#{op} a b)"
+          expect((e.send op, f).sexpr).to eq "(#{op} e f)"
+        end
+
+        it "casts to correct type if possible" do
+          expect((a.send op, e).sexpr).to eq "(#{op} (to_real a) e)"
+          expect((e.send op, a).sexpr).to eq "(#{op} e (to_real a))"
+          expect((a.send op, 42).sexpr).to eq "(#{op} a 42)"
+          expect((42.send op, a).sexpr).to eq "(#{op} 42 a)"
+          expect((a.send op, 42.5).sexpr).to eq "(#{op} (to_real a) (/ 85.0 2.0))"
+          expect((42.5.send op, a).sexpr).to eq "(#{op} (/ 85.0 2.0) (to_real a))"
+          expect((e.send op, 42).sexpr).to eq "(#{op} e 42.0)"
+          expect((42.send op, e).sexpr).to eq "(#{op} 42.0 e)"
+          expect((e.send op, 42.5).sexpr).to eq "(#{op} e (/ 85.0 2.0))"
+          expect((42.5.send op, e).sexpr).to eq "(#{op} (/ 85.0 2.0) e)"
+        end
+
+        it "raises exception if type cast is not possible" do
+          # Int/Real has #>= #+ etc. but they don't like these arguments
+          expect{a.send op, c}.to raise_error(ArgumentError)
+          expect{e.send op, c}.to raise_error(ArgumentError)
+          expect{a.send op, true}.to raise_error(ArgumentError)
+          expect{a.send op, false}.to raise_error(ArgumentError)
+          expect{e.send op, true}.to raise_error(ArgumentError)
+          expect{e.send op, false}.to raise_error(ArgumentError)
+
+          # Bool doesn't have #>= #+ etc.
+          expect{c.send op, a}.to raise_error(NoMethodError)
+          expect{c.send op, d}.to raise_error(NoMethodError)
+          expect{c.send op, e}.to raise_error(NoMethodError)
+          expect{c.send op, true}.to raise_error(NoMethodError)
+          expect{c.send op, false}.to raise_error(NoMethodError)
+        end
+      end
     end
 
-    it "casts to correct type if possible" do
-      expect((a == 42).to_s).to eq "(= a 42)"
-      expect((42 == a).to_s).to eq "(= a 42)"
-      expect((a == e).to_s).to eq "(= (to_real a) e)"
-      expect((e == a).to_s).to eq "(= e (to_real a))"
-      expect((c == true).to_s).to eq "(= c true)"
-      expect((c == false).to_s).to eq "(= c false)"
-      expect((a == 42.5).to_s).to eq "(= (to_real a) (/ 85.0 2.0))"
-      expect((42.5 == a).to_s).to eq "(= (to_real a) (/ 85.0 2.0))"
-      expect((e == 42.5).to_s).to eq "(= e (/ 85.0 2.0))"
-      expect((42.5 == e).to_s).to eq "(= e (/ 85.0 2.0))"
-      # expect((true == c).to_s).to eq "(= true c)"
-      # expect((false == c).to_s).to eq "(= false c)"
-    end
+    describe "#==" do
+      it "allows == of variables of same sort" do
+        expect((a == b).sexpr).to eq "(= a b)"
+        expect((c == d).sexpr).to eq "(= c d)"
+        expect((e == f).sexpr).to eq "(= e f)"
+      end
 
-    it "raises exception if type cast is not possible" do
-      expect{a == c}.to raise_error(ArgumentError)
-      expect{e == c}.to raise_error(ArgumentError)
-      expect{a == true}.to raise_error(ArgumentError)
-      expect{e == true}.to raise_error(ArgumentError)
-      # expect{true == a}.to raise_error(ArgumentError)
-      # expect{true == e}.to raise_error(ArgumentError)
-      expect{c == 42}.to raise_error(ArgumentError)
-      expect{c == 42.5}.to raise_error(ArgumentError)
-      expect{42 == c}.to raise_error(ArgumentError)
-      expect{42.5 == c}.to raise_error(ArgumentError)
-    end
-  end
+      it "casts to correct type if possible" do
+        expect((a == 42).sexpr).to eq "(= a 42)"
+        expect((42 == a).sexpr).to eq "(= a 42)"
+        expect((a == e).sexpr).to eq "(= (to_real a) e)"
+        expect((e == a).sexpr).to eq "(= e (to_real a))"
+        expect((c == true).sexpr).to eq "(= c true)"
+        expect((c == false).sexpr).to eq "(= c false)"
+        expect((a == 42.5).sexpr).to eq "(= (to_real a) (/ 85.0 2.0))"
+        expect((42.5 == a).sexpr).to eq "(= (to_real a) (/ 85.0 2.0))"
+        expect((e == 42.5).sexpr).to eq "(= e (/ 85.0 2.0))"
+        expect((42.5 == e).sexpr).to eq "(= e (/ 85.0 2.0))"
+        # expect((true == c).sexpr).to eq "(= true c)"
+        # expect((false == c).sexpr).to eq "(= false c)"
+      end
 
-  describe "#!=" do
-    it "allows != of variables of same sort" do
-      expect((a != b).to_s).to eq "(distinct a b)"
-      expect((c != d).to_s).to eq "(distinct c d)"
-      expect((e != f).to_s).to eq "(distinct e f)"
+      it "raises exception if type cast is not possible" do
+        expect{a == c}.to raise_error(ArgumentError)
+        expect{e == c}.to raise_error(ArgumentError)
+        expect{a == true}.to raise_error(ArgumentError)
+        expect{e == true}.to raise_error(ArgumentError)
+        # expect{true == a}.to raise_error(ArgumentError)
+        # expect{true == e}.to raise_error(ArgumentError)
+        expect{c == 42}.to raise_error(ArgumentError)
+        expect{c == 42.5}.to raise_error(ArgumentError)
+        expect{42 == c}.to raise_error(ArgumentError)
+        expect{42.5 == c}.to raise_error(ArgumentError)
+      end
     end
 
-    it "casts to correct type if possible" do
-      expect((a != 42).to_s).to eq "(distinct a 42)"
-      # expect((42 != a).to_s).to eq "(distinct a 42)"
-      expect((a != e).to_s).to eq "(distinct (to_real a) e)"
-      expect((e != a).to_s).to eq "(distinct e (to_real a))"
-      expect((c != true).to_s).to eq "(distinct c true)"
-      expect((c != false).to_s).to eq "(distinct c false)"
-      expect((a != 42.5).to_s).to eq "(distinct (to_real a) (/ 85.0 2.0))"
-      # expect((42.5 != a).to_s).to eq "(distinct (to_real a) (/ 85.0 2.0))"
-      expect((e != 42.5).to_s).to eq "(distinct e (/ 85.0 2.0))"
-      # expect((42.5 != e).to_s).to eq "(distinct e (/ 85.0 2.0))"
-      # expect((true != c).to_s).to eq "(distinct true c)"
-      # expect((false != c).to_s).to eq "(distinct false c)"
-    end
+    describe "#!=" do
+      it "allows != of variables of same sort" do
+        expect((a != b).sexpr).to eq "(distinct a b)"
+        expect((c != d).sexpr).to eq "(distinct c d)"
+        expect((e != f).sexpr).to eq "(distinct e f)"
+      end
+
+      it "casts to correct type if possible" do
+        expect((a != 42).sexpr).to eq "(distinct a 42)"
+        # expect((42 != a).sexpr).to eq "(distinct a 42)"
+        expect((a != e).sexpr).to eq "(distinct (to_real a) e)"
+        expect((e != a).sexpr).to eq "(distinct e (to_real a))"
+        expect((c != true).sexpr).to eq "(distinct c true)"
+        expect((c != false).sexpr).to eq "(distinct c false)"
+        expect((a != 42.5).sexpr).to eq "(distinct (to_real a) (/ 85.0 2.0))"
+        # expect((42.5 != a).sexpr).to eq "(distinct (to_real a) (/ 85.0 2.0))"
+        expect((e != 42.5).sexpr).to eq "(distinct e (/ 85.0 2.0))"
+        # expect((42.5 != e).sexpr).to eq "(distinct e (/ 85.0 2.0))"
+        # expect((true != c).sexpr).to eq "(distinct true c)"
+        # expect((false != c).sexpr).to eq "(distinct false c)"
+      end
 
-    it "raises exception if type cast is not possible" do
-      expect{a != c}.to raise_error(ArgumentError)
-      expect{e != c}.to raise_error(ArgumentError)
-      expect{a != true}.to raise_error(ArgumentError)
-      expect{e != true}.to raise_error(ArgumentError)
-      # expect{true != a}.to raise_error(ArgumentError)
-      # expect{true != e}.to raise_error(ArgumentError)
-      expect{c != 42}.to raise_error(ArgumentError)
-      expect{c != 42.5}.to raise_error(ArgumentError)
-      # expect{42 != c}.to raise_error(ArgumentError)
-      # expect{42.5 != c}.to raise_error(ArgumentError)
+      it "raises exception if type cast is not possible" do
+        expect{a != c}.to raise_error(ArgumentError)
+        expect{e != c}.to raise_error(ArgumentError)
+        expect{a != true}.to raise_error(ArgumentError)
+        expect{e != true}.to raise_error(ArgumentError)
+        # expect{true != a}.to raise_error(ArgumentError)
+        # expect{true != e}.to raise_error(ArgumentError)
+        expect{c != 42}.to raise_error(ArgumentError)
+        expect{c != 42.5}.to raise_error(ArgumentError)
+        # expect{42 != c}.to raise_error(ArgumentError)
+        # expect{42.5 != c}.to raise_error(ArgumentError)
+      end
     end
   end
 end

data/spec/float_expr_spec.rb

@@ -0,0 +1,167 @@
+module Z3
+  describe FloatExpr do
+    let(:mode) { RoundingModeSort.new }
+    let(:float_double) { FloatSort.new(:double) }
+    let(:a) { float_double.var("a") }
+    let(:b) { float_double.var("b") }
+    let(:c) { float_double.var("c") }
+    let(:m) { mode.var("m") }
+    let(:x) { BoolSort.new.var("x") }
+
+    let(:positive_zero) { float_double.positive_zero }
+    let(:negative_zero) { float_double.negative_zero }
+    let(:positive_infinity) { float_double.positive_infinity }
+    let(:negative_infinity) { float_double.negative_infinity }
+    let(:nan) { float_double.nan }
+
+    it "+" do
+      expect([a == 2.0, b == 4.0, c == a.add(b,m)]).to have_solution(
+        c => float_double.from_const(6.0),
+      )
+    end
+
+    it "*" do
+      expect([a == -2.0, b == 0.5, c == a.mul(b,m)]).to have_solution(
+        c => float_double.from_const(-1.0),
+      )
+    end
+
+    it "-" do
+      expect([a == 2.0, b == 0.5, c == a.sub(b,m)]).to have_solution(
+        c => float_double.from_const(1.5),
+      )
+    end
+
+    it "/" do
+      expect([a == 12.0, b == 3.0, c == a.div(b,m)]).to have_solution(
+        c => float_double.from_const(4.0),
+      )
+    end
+
+    it "%" do
+      expect([a == 13.5, b == 3.0, c == a.rem(b)]).to have_solution(
+        c => float_double.from_const(1.5),
+      )
+    end
+
+    it "abs" do
+      expect([a == 7.5, c == a.abs]).to have_solution(
+        c => float_double.from_const(7.5),
+      )
+      expect([a == -7.5, c == a.abs]).to have_solution(
+        c => float_double.from_const(7.5),
+      )
+    end
+
+    it "neg" do
+      expect([a == 7.5, c == -a]).to have_solution(
+        c => float_double.from_const(7.5),
+      )
+      expect([a == -7.5, c == -a]).to have_solution(
+        c => float_double.from_const(7.5),
+      )
+    end
+
+    # Broken in z3
+    # it "max" do
+    #   expect([a == 2.0, b == 3.0, c == a.max(b)]).to have_solution(
+    #     c => float_double.from_const(3.0),
+    #   )
+    # end
+
+    it "min" do
+      expect([a == 2.0, b == 3.0, c == a.min(b)]).to have_solution(
+        c => float_double.from_const(2.0),
+      )
+    end
+
+    it "comparisons" do
+      expect([a == 3.0, b == 3.0, x == (a >= b)]).to have_solution(x => true)
+      expect([a == 3.0, b == 3.0, x == (a >  b)]).to have_solution(x => false)
+      expect([a == 3.0, b == 3.0, x == (a <= b)]).to have_solution(x => true)
+      expect([a == 3.0, b == 3.0, x == (a <  b)]).to have_solution(x => false)
+      expect([a == 3.0, b == 3.0, x == (a == b)]).to have_solution(x => true)
+      expect([a == 3.0, b == 3.0, x == (a != b)]).to have_solution(x => false)
+
+      expect([a == 3.0, b == 2.0, x == (a >= b)]).to have_solution(x => true)
+      expect([a == 3.0, b == 2.0, x == (a >  b)]).to have_solution(x => true)
+      expect([a == 3.0, b == 2.0, x == (a <= b)]).to have_solution(x => false)
+      expect([a == 3.0, b == 2.0, x == (a <  b)]).to have_solution(x => false)
+      expect([a == 3.0, b == 2.0, x == (a == b)]).to have_solution(x => false)
+      expect([a == 3.0, b == 2.0, x == (a != b)]).to have_solution(x => true)
+    end
+
+    # This isn't the most amazing format ever, probably reevaluate it completely at some point
+    it "to_s" do
+      expect(float_double.from_const(1.0).to_s).to eq("1B+0")
+      expect(float_double.from_const(2.0).to_s).to eq("1B+1")
+      expect(float_double.from_const(0.5).to_s).to eq("1B-1")
+      expect(positive_zero.to_s).to eq("+zero")
+      expect(negative_zero.to_s).to eq("-zero")
+      expect(positive_infinity.to_s).to eq("+oo")
+      expect(negative_infinity.to_s).to eq("-oo")
+      expect(nan.to_s).to eq("NaN")
+      expect(float_double.from_const(1234 * 0.5**1040).to_s).to eq("1.205078125B-1030")
+    end
+
+    it "zero?" do
+      expect([x == positive_zero.zero?]).to have_solution(x => true)
+      expect([x == negative_zero.zero?]).to have_solution(x => true)
+      expect([x == positive_infinity.zero?]).to have_solution(x => false)
+      expect([x == negative_infinity.zero?]).to have_solution(x => false)
+      expect([x == float_double.from_const(1.5).zero?]).to have_solution(x => false)
+      expect([x == nan.zero?]).to have_solution(x => false)
+    end
+
+    it "infinite?" do
+      expect([x == positive_zero.infinite?]).to have_solution(x => false)
+      expect([x == positive_infinity.infinite?]).to have_solution(x => true)
+      expect([x == negative_infinity.infinite?]).to have_solution(x => true)
+      expect([x == float_double.from_const(1.5).infinite?]).to have_solution(x => false)
+      expect([x == nan.infinite?]).to have_solution(x => false)
+    end
+
+    it "nan?" do
+      expect([x == positive_zero.nan?]).to have_solution(x => false)
+      expect([x == positive_infinity.nan?]).to have_solution(x => false)
+      expect([x == float_double.from_const(1.5).nan?]).to have_solution(x => false)
+      expect([x == nan.nan?]).to have_solution(x => true)
+    end
+
+    it "normal?" do
+      expect([x == positive_zero.normal?]).to have_solution(x => false)
+      expect([x == positive_infinity.normal?]).to have_solution(x => false)
+      expect([x == nan.normal?]).to have_solution(x => false)
+      expect([x == float_double.from_const(1.5).normal?]).to have_solution(x => true)
+      expect([x == float_double.from_const(1234 * 0.5**1040).normal?]).to have_solution(x => false)
+    end
+
+    it "subnormal?" do
+      expect([x == positive_zero.subnormal?]).to have_solution(x => false)
+      expect([x == positive_infinity.subnormal?]).to have_solution(x => false)
+      expect([x == nan.subnormal?]).to have_solution(x => false)
+      expect([x == float_double.from_const(1.5).subnormal?]).to have_solution(x => false)
+      expect([x == float_double.from_const(1234 * 0.5**1040).subnormal?]).to have_solution(x => true)
+    end
+
+    it "positive?" do
+      expect([x == positive_zero.positive?]).to have_solution(x => true)
+      expect([x == negative_zero.positive?]).to have_solution(x => false)
+      expect([x == positive_infinity.positive?]).to have_solution(x => true)
+      expect([x == negative_infinity.positive?]).to have_solution(x => false)
+      expect([x == float_double.from_const(1.5).positive?]).to have_solution(x => true)
+      expect([x == float_double.from_const(-1.5).positive?]).to have_solution(x => false)
+      expect([x == nan.positive?]).to have_solution(x => false)
+    end
+
+    it "negative?" do
+      expect([x == positive_zero.negative?]).to have_solution(x => false)
+      expect([x == negative_zero.negative?]).to have_solution(x => true)
+      expect([x == positive_infinity.negative?]).to have_solution(x => false)
+      expect([x == negative_infinity.negative?]).to have_solution(x => true)
+      expect([x == float_double.from_const(1.5).negative?]).to have_solution(x => false)
+      expect([x == float_double.from_const(-1.5).negative?]).to have_solution(x => true)
+      expect([x == nan.negative?]).to have_solution(x => false)
+    end
+  end
+end

data/spec/float_sort_spec.rb

@@ -0,0 +1,44 @@
+module Z3
+  describe FloatSort do
+    let(:float_16)        { FloatSort.new(16) }
+    let(:float_32)        { FloatSort.new(32) }
+    let(:float_64)        { FloatSort.new(64) }
+    let(:float_128)       { FloatSort.new(128) }
+    let(:float_half)      { FloatSort.new(:half) }
+    let(:float_single)    { FloatSort.new(:single) }
+    let(:float_double)    { FloatSort.new(:double) }
+    let(:float_quadruple) { FloatSort.new(:quadruple) }
+    let(:float_5_11)      { FloatSort.new(5, 11) }
+    let(:float_8_24)      { FloatSort.new(8, 24) }
+    let(:float_11_53)     { FloatSort.new(11, 53) }
+    let(:float_15_113)    { FloatSort.new(15, 113) }
+
+    it "to_s" do
+      expect(float_5_11.to_s).to eq("Float(5, 11)")
+      expect(float_15_113.to_s).to eq("Float(15, 113)")
+    end
+
+    it "inspect" do
+      expect(float_5_11.inspect).to eq("FloatSort(5, 11)")
+      expect(float_15_113.inspect).to eq("FloatSort(15, 113)")
+    end
+
+    it "sbits" do
+      expect(float_8_24.sbits).to eq(24)
+      expect(float_11_53.sbits).to eq(53)
+    end
+
+    it "ebits" do
+      expect(float_8_24.ebits).to eq(8)
+      expect(float_11_53.ebits).to eq(11)
+    end
+
+    it "shortcut syntax" do
+      expect([float_16, float_32, float_64, float_128]).to be_all_different
+      expect([float_16, float_half, float_5_11]).to be_all_same
+      expect([float_32, float_single, float_8_24]).to be_all_same
+      expect([float_64, float_double, float_11_53]).to be_all_same
+      expect([float_128, float_quadruple, float_15_113]).to be_all_same
+    end
+  end
+end

data/spec/goal_spec.rb

@@ -0,0 +1,17 @@
+module Z3
+  describe Goal do
+    it "basic functionality" do
+      g = Goal.new
+      g.assert Z3.Int("x") == 3
+      expect(g.num_exprs).to eq(3)
+      expect(g.size).to eq(1)
+      expect(g.depth).to eq(0)
+      expect(g.precision).to eq(0)
+      expect(g.to_s).to eq("(goal\n  (= x 3))")
+      expect(g.decided_sat?).to eq(false)
+      expect(g.decided_unsat?).to eq(false)
+      expect(g.inconsistent?).to eq(false)
+      expect(g.formula(0).to_s).to eq("x = 3")
+    end
+  end
+end