z3 0.0.20160427 → 0.0.20161008

data/spec/int_expr_spec.rb

@@ -1,78 +1,91 @@
-describe Z3::IntExpr do
-  let(:a) { Z3::Int("a") }
-  let(:b) { Z3::Int("b") }
-  let(:c) { Z3::Int("c") }
-  let(:x) { Z3::Bool("x") }
+module Z3
+  describe IntExpr do
+    let(:a) { Z3.Int("a") }
+    let(:b) { Z3.Int("b") }
+    let(:c) { Z3.Int("c") }
+    let(:x) { Z3.Bool("x") }
 
-  it "+" do
-    expect([a == 2, b == 4, c == a + b]).to have_solution(c => 6)
-  end
+    it "+" do
+      expect([a == 2, b == 4, c == a + b]).to have_solution(c => 6)
+    end
 
-  it "-" do
-    expect([a == 2, b == 4, c == a - b]).to have_solution(c => -2)
-  end
+    it "-" do
+      expect([a == 2, b == 4, c == a - b]).to have_solution(c => -2)
+    end
 
-  it "*" do
-    expect([a == 2, b == 4, c == a * b]).to have_solution(c => 8)
-  end
+    it "*" do
+      expect([a == 2, b == 4, c == a * b]).to have_solution(c => 8)
+    end
 
-  it "/" do
-    expect([a ==  10, b ==  3, c == a / b]).to have_solution(c =>  3)
-    expect([a == -10, b ==  3, c == a / b]).to have_solution(c => -4)
-    expect([a ==  10, b == -3, c == a / b]).to have_solution(c => -3)
-    expect([a == -10, b == -3, c == a / b]).to have_solution(c =>  4)
-  end
+    it "/" do
+      expect([a ==  10, b ==  3, c == a / b]).to have_solution(c =>  3)
+      expect([a == -10, b ==  3, c == a / b]).to have_solution(c => -4)
+      expect([a ==  10, b == -3, c == a / b]).to have_solution(c => -3)
+      expect([a == -10, b == -3, c == a / b]).to have_solution(c =>  4)
+    end
 
-  # Can't say these make much sense, but let's document what Z3 actually does
-  it "rem" do
-    expect([a ==  10, b ==  3, c == a.rem(b)]).to have_solution(c => 10 -  3 *  3)
-    expect([a == -10, b ==  3, c == a.rem(b)]).to have_solution(c =>-10 -  3 * -4)
-    expect([a ==  10, b == -3, c == a.rem(b)]).to have_solution(c =>-( 10 - -3 * -3))
-    expect([a == -10, b == -3, c == a.rem(b)]).to have_solution(c =>-(-10 - -3 *  4))
-  end
+    # Can't say these make much sense, but let's document what Z3 actually does
+    it "rem" do
+      expect([a ==  10, b ==  3, c == a.rem(b)]).to have_solution(c => 10 -  3 *  3)
+      expect([a == -10, b ==  3, c == a.rem(b)]).to have_solution(c =>-10 -  3 * -4)
+      expect([a ==  10, b == -3, c == a.rem(b)]).to have_solution(c =>-( 10 - -3 * -3))
+      expect([a == -10, b == -3, c == a.rem(b)]).to have_solution(c =>-(-10 - -3 *  4))
+    end
 
-  it "mod" do
-    expect([a ==  10, b ==  3, c == a.mod(b)]).to have_solution(c => 1)
-    expect([a ==  10, b == -3, c == a.mod(b)]).to have_solution(c => 1)
-    expect([a == -10, b ==  3, c == a.mod(b)]).to have_solution(c => 2)
-    expect([a == -10, b == -3, c == a.mod(b)]).to have_solution(c => 2)
-  end
+    it "mod" do
+      expect([a ==  10, b ==  3, c == a.mod(b)]).to have_solution(c => 1)
+      expect([a ==  10, b == -3, c == a.mod(b)]).to have_solution(c => 1)
+      expect([a == -10, b ==  3, c == a.mod(b)]).to have_solution(c => 2)
+      expect([a == -10, b == -3, c == a.mod(b)]).to have_solution(c => 2)
+    end
 
-  it "==" do
-    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 == 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 == 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 == 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 == 3, b == 2, x == (a > b)]).to have_solution(x => true)
-    expect([a == 2, b == 2, x == (a > b)]).to have_solution(x => false)
-    expect([a == 1, b == 2, x == (a > b)]).to have_solution(x => false)
-  end
+    it ">" do
+      expect([a == 3, b == 2, x == (a > b)]).to have_solution(x => true)
+      expect([a == 2, b == 2, x == (a > b)]).to have_solution(x => false)
+      expect([a == 1, b == 2, x == (a > b)]).to have_solution(x => false)
+    end
 
-  it ">=" do
-    expect([a == 3, b == 2, x == (a >= b)]).to have_solution(x => true)
-    expect([a == 2, b == 2, x == (a >= b)]).to have_solution(x => true)
-    expect([a == 1, b == 2, x == (a >= b)]).to have_solution(x => false)
-  end
+    it ">=" do
+      expect([a == 3, b == 2, x == (a >= b)]).to have_solution(x => true)
+      expect([a == 2, b == 2, x == (a >= b)]).to have_solution(x => true)
+      expect([a == 1, b == 2, x == (a >= b)]).to have_solution(x => false)
+    end
 
-  it "<" do
-    expect([a == 3, b == 2, x == (a < b)]).to have_solution(x => false)
-    expect([a == 2, b == 2, x == (a < b)]).to have_solution(x => false)
-    expect([a == 1, b == 2, x == (a < b)]).to have_solution(x => true)
-  end
+    it "<" do
+      expect([a == 3, b == 2, x == (a < b)]).to have_solution(x => false)
+      expect([a == 2, b == 2, x == (a < b)]).to have_solution(x => false)
+      expect([a == 1, b == 2, x == (a < b)]).to have_solution(x => true)
+    end
 
-  it "<=" do
-    expect([a == 3, b == 2, x == (a <= b)]).to have_solution(x => false)
-    expect([a == 2, b == 2, x == (a <= b)]).to have_solution(x => true)
-    expect([a == 1, b == 2, x == (a <= b)]).to have_solution(x => true)
-  end
+    it "<=" do
+      expect([a == 3, b == 2, x == (a <= b)]).to have_solution(x => false)
+      expect([a == 2, b == 2, x == (a <= b)]).to have_solution(x => true)
+      expect([a == 1, b == 2, x == (a <= b)]).to have_solution(x => true)
+    end
+
+    it "**" do
+      expect([a == 3, b == 4, c == (a ** b)]).to have_solution(c => 81)
+    end
+
+    it "unary -" do
+      expect([a == 3, b == -a]).to have_solution(b => -3)
+    end
 
-  it "**" do
-    expect([a == 3, b == 4, c == (a ** b)]).to have_solution(c => 81)
+    it "simplify" do
+      a = Z3.Const(5)
+      b = Z3.Const(3)
+      expect((a+b).inspect).to eq("Int<5 + 3>")
+      expect((a+b).simplify.inspect).to eq("Int<8>")
+    end
   end
 end

data/spec/int_sort_spec.rb

@@ -1,18 +1,20 @@
-describe Z3::IntSort do
-  it "can instantiate constants" do
-    expect(subject.from_const(0).inspect).to eq("Int<0>")
-    expect(subject.from_const(42).inspect).to eq("Int<42>")
-    expect(subject.from_const(1_000_000_000_000).inspect).to eq("Int<1000000000000>")
-    expect(subject.from_const(-1_000_000_000_000).inspect).to eq("Int<-1000000000000>")
-  end
+module Z3
+  describe IntSort do
+    it "can instantiate constants" do
+      expect(subject.from_const(0).inspect).to eq("Int<0>")
+      expect(subject.from_const(42).inspect).to eq("Int<42>")
+      expect(subject.from_const(1_000_000_000_000).inspect).to eq("Int<1000000000000>")
+      expect(subject.from_const(-1_000_000_000_000).inspect).to eq("Int<-1000000000000>")
+    end
 
-  it "raises exception when trying to convert constants of wrong type" do
-    expect{ subject.from_const(true) }.to raise_error(Z3::Exception)
-    expect{ subject.from_const(false) }.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(true) }.to raise_error(Z3::Exception)
+      expect{ subject.from_const(false) }.to raise_error(Z3::Exception)
+      expect{ subject.from_const(0.0) }.to raise_error(Z3::Exception)
+    end
 
-  it "can instantiate variables" do
-    expect(Z3.Int("a").inspect).to eq("Int<a>")
+    it "can instantiate variables" do
+      expect(Z3.Int("a").inspect).to eq("Int<a>")
+    end
   end
 end

data/spec/integration/algebra_problems_spec.rb

@@ -4,14 +4,14 @@ describe "Algebra Problems" do
 Solution to problem 01:
 Solution to problem 03:
 * x = -22
-* |\\|-6\\|| = 6
-* |\\|x-2\\|| = 24
+* |-6| = 6
+* |x-2| = 24
 Solution to problem 04:
 * ax = -4
 * ay = -5
 * bx = -1
 * by = -1
-* |\\|a-b\\|| = 5
+* |a-b| = 5
 Solution to problem 05:
 * x = 9/2
 * y = 0
@@ -23,7 +23,7 @@ Solution to problem 06:
 * y2 = 13
 Solution to problem 10:
 * x = 1
-* |\\|-2x + 2\\|| = 0
+* |-2x + 2| = 0
 EOF
   end
 end

data/spec/integration/cicruit_problem_spec.rb

@@ -0,0 +1,23 @@
+describe "Circuit Problems" do
+  it do
+    expect("circuit_problems").to have_output <<EOF
+Problem 1
+* I V = -5/4
+
+Problem 2
+* I V = -10
+
+Problem 3
+* I L = -1
+* I V = -1
+* I L = -1/2
+* I V = -1/2
+* I L = 0
+* I V = 0
+* I L = -1/2
+* I V = 1/2
+* I L = -1
+* I V = 1
+EOF
+  end
+end

data/spec/integration/geometry_problem_spec.rb

@@ -2,15 +2,15 @@ describe "Geometry Problem" do
   it do
     expect("geometry_problem").to have_output <<EOF
 * a.x = 0
-* a.y = (root-obj (+ (^ x 2) (- 300)) 1)
+* a.y = -17.3205080756?
 * b.x = 0
 * b.y = 0
 * c.x = 10
 * c.y = 0
 * d.x = 10
-* d.y = (root-obj (+ (^ x 2) (- 300)) 1)
-* |\\|a-c\\|| = -20
-* |\\|b-d\\|| = 20
+* d.y = -17.3205080756?
+* |a-c| = -20
+* |b-d| = 20
 EOF
   end
 end

data/spec/integration/kinematics_problems_spec.rb

@@ -23,7 +23,7 @@ Solution to problem 04:
 Solution to problem 05:
 * a = 167/100
 * d = 7/5
-* t = (root-obj (+ (* 167 (^ x 2)) (- 280)) 2)
+* t = 1.2948539325?
 Solution to problem 06:
 * a = 14800/61
 * d = 20313/50
@@ -46,8 +46,8 @@ Solution to problem 09:
 Solution to problem 10:
 * a = -981/100
 * d = 131/50
-* t = (root-obj (+ (* 981 (^ x 2)) (- 524)) 2)
-* v = (root-obj (+ (* 2500 (^ x 2)) (- 128511)) 2)
+* t = 0.7308548609?
+* v = 7.1696861856?
 EOF
   end
 end

data/spec/model_spec.rb

@@ -1,44 +1,46 @@
 # Solver and Model specs are codependent, so half of functionality of each is tested in other class's tests
-describe Z3::Model do
-  let(:solver) { Z3::Solver.new }
-  let(:a) { Z3.Int("a") }
-  let(:b) { Z3.Int("b") }
-  let(:c) { Z3.Int("c") }
-  let(:model) { solver.model }
+module Z3
+  describe Model do
+    let(:solver) { Solver.new }
+    let(:a) { Z3.Int("a") }
+    let(:b) { Z3.Int("b") }
+    let(:c) { Z3.Int("c") }
+    let(:model) { solver.model }
 
-  it "knows how many variables are in the model" do
-    solver.assert(a == 2)
-    solver.assert(b == a+2)
-    expect(solver.check).to eq(:sat)
-    expect(model.num_consts).to eq(2)
-    expect(model.num_funcs).to eq(0)
-    expect(model.num_sorts).to eq(0)
-  end
+    it "knows how many variables are in the model" do
+      solver.assert(a == 2)
+      solver.assert(b == a+2)
+      expect(solver.check).to eq(:sat)
+      expect(model.num_consts).to eq(2)
+      expect(model.num_funcs).to eq(0)
+      expect(model.num_sorts).to eq(0)
+    end
 
-  it "can evaluate variables" do
-    solver.assert(a == 2)
-    solver.assert(b == a+2)
-    expect(solver.check).to eq(:sat)
-    expect(model.model_eval(a)).to be_same_as(Z3.Const(2))
-    expect(model.model_eval(b)).to be_same_as(Z3.Const(4))
-    expect(model.model_eval(c)).to be_same_as(c)
-    expect(model.model_eval(a, true)).to be_same_as(Z3.Const(2))
-    expect(model.model_eval(b, true)).to be_same_as(Z3.Const(4))
-    expect(model.model_eval(c, true)).to be_same_as(Z3.Const(0))
-  end
+    it "can evaluate variables" do
+      solver.assert(a == 2)
+      solver.assert(b == a+2)
+      expect(solver.check).to eq(:sat)
+      expect(model.model_eval(a)).to be_same_as(Z3.Const(2))
+      expect(model.model_eval(b)).to be_same_as(Z3.Const(4))
+      expect(model.model_eval(c)).to be_same_as(c)
+      expect(model.model_eval(a, true)).to be_same_as(Z3.Const(2))
+      expect(model.model_eval(b, true)).to be_same_as(Z3.Const(4))
+      expect(model.model_eval(c, true)).to be_same_as(Z3.Const(0))
+    end
 
-  it "#to_a" do
-    solver.assert(a == 2)
-    solver.assert(b == a+2)
-    expect(solver.check).to eq(:sat)
-    expect(model.to_a).to be_same_as([[Z3.Int("a"), Z3.Const(2)], [Z3.Int("b"), Z3.Const(4)]])
-  end
+    it "#to_a" do
+      solver.assert(a == 2)
+      solver.assert(b == a+2)
+      expect(solver.check).to eq(:sat)
+      expect(model.to_a).to be_same_as([[Z3.Int("a"), Z3.Const(2)], [Z3.Int("b"), Z3.Const(4)]])
+    end
 
-  it "#to_s" do
-    solver.assert(a == 2)
-    solver.assert(b == a+2)
-    expect(solver.check).to eq(:sat)
-    expect(model.to_s).to eq("Z3::Model<a=2, b=4>")
-    expect(model.inspect).to eq("Z3::Model<a=2, b=4>")
+    it "#to_s" do
+      solver.assert(a == 2)
+      solver.assert(b == a+2)
+      expect(solver.check).to eq(:sat)
+      expect(model.to_s).to eq("Z3::Model<a=2, b=4>")
+      expect(model.inspect).to eq("Z3::Model<a=2, b=4>")
+    end
   end
 end

data/spec/printer_spec.rb

@@ -1,22 +1,53 @@
-describe Z3::Printer do
-  it "numbers" do
-    expect(Z3::IntSort.new.from_const(42)).to stringify("42")
-    expect(Z3::IntSort.new.from_const(-42)).to stringify("-42")
-    expect(Z3::RealSort.new.from_const(42)).to stringify("42")
-    expect(Z3::RealSort.new.from_const(-42)).to stringify("-42")
-    expect(Z3::RealSort.new.from_const(3.14)).to stringify("157/50")
-    expect(Z3::RealSort.new.from_const(-3.14)).to stringify("-157/50")
-  end
+module Z3
+  describe Printer do
+    it "numbers" do
+      expect(IntSort.new.from_const(42)).to stringify("42")
+      expect(IntSort.new.from_const(-42)).to stringify("-42")
+      expect(RealSort.new.from_const(42)).to stringify("42")
+      expect(RealSort.new.from_const(-42)).to stringify("-42")
+      expect(RealSort.new.from_const(3.14)).to stringify("157/50")
+      expect(RealSort.new.from_const(-3.14)).to stringify("-157/50")
+    end
 
-  it "booleans" do
-    expect(Z3.True).to stringify("true")
-    expect(Z3.False).to stringify("false")
-  end
+    it "booleans" do
+      expect(Z3.True).to stringify("true")
+      expect(Z3.False).to stringify("false")
+    end
+
+    it "variables" do
+      expect(Z3.Int("a")).to stringify("a")
+      expect(Z3.Real("a")).to stringify("a")
+      expect(Z3.Bool("a")).to stringify("a")
+      expect(Z3.Bitvec("a", 32)).to stringify("a")
+    end
+
+    describe "expressions" do
+      let(:a) { Z3.Int("a") }
+      let(:b) { Z3.Int("b") }
+      let(:c) { Z3.Int("c") }
+
+      it "binary operators" do
+        expect(a + b).to stringify("a + b")
+        expect(a - b).to stringify("a - b")
+        expect(a * b).to stringify("a * b")
+        expect(a / b).to stringify("div(a, b)")
+        expect(a.mod b).to stringify("mod(a, b)")
+        expect(a.rem b).to stringify("rem(a, b)")
+      end
+
+      it "parentheses" do
+        expect(a + b + c).to stringify("(a + b) + c")
+        expect(a + b * c).to stringify("a + (b * c)")
+        expect((a + b) * c).to stringify("(a + b) * c")
+        expect(a.mod(b + c)).to stringify("mod(a, b + c)")
+        expect(a.mod(b) + c).to stringify("mod(a, b) + c")
+      end
 
-  it "variables" do
-    expect(Z3::Int("a")).to stringify("a")
-    expect(Z3::Real("a")).to stringify("a")
-    expect(Z3::Bool("a")).to stringify("a")
-    expect(Z3::Bitvec("a", 32)).to stringify("a")
+      it "unary operators" do
+        expect(-a).to stringify("-a")
+        expect(-(a + b)).to stringify("-(a + b)")
+        expect((-a) + (-b)).to stringify("(-a) + (-b)")
+      end
+    end
   end
 end

data/spec/probe_spec.rb

@@ -0,0 +1,17 @@
+module Z3
+  describe Probe do
+    it "names" do
+      expect(Probe.names).to include("num-consts")
+    end
+
+    # Just simple way to brute force coverage
+    it "probe building" do
+      a = Probe.named("num-consts") < Probe.const(10.0)
+      b = Probe.named("size") <= Probe.named("depth")
+      c = Probe.named("num-bool-consts") > Probe.const(1.5)
+      d = Probe.named("memory") >= Probe.const(4000)
+      e = (a == b) & (~c | d)
+      expect(e.is_a?(Probe)).to be true
+    end
+  end
+end

data/spec/real_expr_spec.rb

@@ -1,64 +1,72 @@
-describe Z3::RealExpr do
-  let(:a) { Z3::Real("a") }
-  let(:b) { Z3::Real("b") }
-  let(:c) { Z3::Real("c") }
-  let(:x) { Z3::Bool("x") }
+module Z3
+  describe RealExpr do
+    let(:a) { Z3.Real("a") }
+    let(:b) { Z3.Real("b") }
+    let(:c) { Z3.Real("c") }
+    let(:x) { Z3.Bool("x") }
 
-  it "+" do
-    expect([a == 2, b == 4, c == a + b]).to have_solution(c => 6)
-  end
+    it "+" do
+      expect([a == 2, b == 4, c == a + b]).to have_solution(c => 6)
+    end
 
-  it "-" do
-    expect([a == 2, b == 4, c == a - b]).to have_solution(c => -2)
-  end
+    it "-" do
+      expect([a == 2, b == 4, c == a - b]).to have_solution(c => -2)
+    end
 
-  it "*" do
-    expect([a == 2, b == 4, c == a * b]).to have_solution(c => 8)
-  end
+    it "*" do
+      expect([a == 2, b == 4, c == a * b]).to have_solution(c => 8)
+    end
 
-  it "/" do
-    expect([a ==  10, b ==  3, c == a / b]).to have_solution(c => "10/3")
-    expect([a == -10, b ==  3, c == a / b]).to have_solution(c => "-10/3")
-    expect([a ==  10, b == -3, c == a / b]).to have_solution(c => "-10/3")
-    expect([a == -10, b == -3, c == a / b]).to have_solution(c => "10/3")
-  end
+    it "/" do
+      expect([a ==  10, b ==  3, c == a / b]).to have_solution(c => "10/3")
+      expect([a == -10, b ==  3, c == a / b]).to have_solution(c => "-10/3")
+      expect([a ==  10, b == -3, c == a / b]).to have_solution(c => "-10/3")
+      expect([a == -10, b == -3, c == a / b]).to have_solution(c => "10/3")
+    end
 
-  it "==" do
-    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 == 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 == 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 == 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 == 3, b == 2, x == (a > b)]).to have_solution(x => true)
-    expect([a == 2, b == 2, x == (a > b)]).to have_solution(x => false)
-    expect([a == 1, b == 2, x == (a > b)]).to have_solution(x => false)
-  end
+    it ">" do
+      expect([a == 3, b == 2, x == (a > b)]).to have_solution(x => true)
+      expect([a == 2, b == 2, x == (a > b)]).to have_solution(x => false)
+      expect([a == 1, b == 2, x == (a > b)]).to have_solution(x => false)
+    end
 
-  it ">=" do
-    expect([a == 3, b == 2, x == (a >= b)]).to have_solution(x => true)
-    expect([a == 2, b == 2, x == (a >= b)]).to have_solution(x => true)
-    expect([a == 1, b == 2, x == (a >= b)]).to have_solution(x => false)
-  end
+    it ">=" do
+      expect([a == 3, b == 2, x == (a >= b)]).to have_solution(x => true)
+      expect([a == 2, b == 2, x == (a >= b)]).to have_solution(x => true)
+      expect([a == 1, b == 2, x == (a >= b)]).to have_solution(x => false)
+    end
 
-  it "<" do
-    expect([a == 3, b == 2, x == (a < b)]).to have_solution(x => false)
-    expect([a == 2, b == 2, x == (a < b)]).to have_solution(x => false)
-    expect([a == 1, b == 2, x == (a < b)]).to have_solution(x => true)
-  end
+    it "<" do
+      expect([a == 3, b == 2, x == (a < b)]).to have_solution(x => false)
+      expect([a == 2, b == 2, x == (a < b)]).to have_solution(x => false)
+      expect([a == 1, b == 2, x == (a < b)]).to have_solution(x => true)
+    end
 
-  it "<=" do
-    expect([a == 3, b == 2, x == (a <= b)]).to have_solution(x => false)
-    expect([a == 2, b == 2, x == (a <= b)]).to have_solution(x => true)
-    expect([a == 1, b == 2, x == (a <= b)]).to have_solution(x => true)
-  end
+    it "<=" do
+      expect([a == 3, b == 2, x == (a <= b)]).to have_solution(x => false)
+      expect([a == 2, b == 2, x == (a <= b)]).to have_solution(x => true)
+      expect([a == 1, b == 2, x == (a <= b)]).to have_solution(x => true)
+    end
+
+    it "**" do
+      expect([a == 3, b == 4, c == (a ** b)]).to have_solution(c => 81)
+      expect([a == 81, b == 0.25, c == (a ** b)]).to have_solution(c => 3)
+    end
 
-  it "**" do
-    expect([a == 3, b == 4, c == (a ** b)]).to have_solution(c => 81)
-    expect([a == 81, b == 0.25, c == (a ** b)]).to have_solution(c => 3)
+    it "unary -" do
+      expect([a == 3, b == -a]).to have_solution(b => -3)
+      expect([a == 0, b == -a]).to have_solution(b => 0)
+      expect([a == 3.5, b == -a]).to have_solution(b => "-7/2")
+    end
   end
 end

data/spec/real_sort_spec.rb

@@ -1,24 +1,26 @@
-describe Z3::RealSort do
-  it "can instantiate constants" do
-    expect(subject.from_const(0).inspect).to eq("Real<0>")
-    expect(subject.from_const(42).inspect).to eq("Real<42>")
-    expect(subject.from_const(1_000_000_000_000).inspect).to eq("Real<1000000000000>")
-    expect(subject.from_const(-1_000_000_000_000).inspect).to eq("Real<-1000000000000>")
-    expect(subject.from_const(0.0).inspect).to eq("Real<0>")
-    expect(subject.from_const(-0.0).inspect).to eq("Real<0>")
-    expect(subject.from_const(3.14).inspect).to eq("Real<157/50>")
-    expect(subject.from_const(-3.14).inspect).to eq("Real<-157/50>")
-  end
+module Z3
+  describe RealSort do
+    it "can instantiate constants" do
+      expect(subject.from_const(0).inspect).to eq("Real<0>")
+      expect(subject.from_const(42).inspect).to eq("Real<42>")
+      expect(subject.from_const(1_000_000_000_000).inspect).to eq("Real<1000000000000>")
+      expect(subject.from_const(-1_000_000_000_000).inspect).to eq("Real<-1000000000000>")
+      expect(subject.from_const(0.0).inspect).to eq("Real<0>")
+      expect(subject.from_const(-0.0).inspect).to eq("Real<0>")
+      expect(subject.from_const(3.14).inspect).to eq("Real<157/50>")
+      expect(subject.from_const(-3.14).inspect).to eq("Real<-157/50>")
+    end
 
-  it "raises exception when trying to convert constants of wrong type" do
-    expect{ subject.from_const(true) }.to raise_error(Z3::Exception)
-    expect{ subject.from_const(false) }.to raise_error(Z3::Exception)
-    expect{ subject.from_const(1.0 / 0.0) }.to raise_error(Z3::Exception)
-    expect{ subject.from_const(-1.0 / 0.0) }.to raise_error(Z3::Exception)
-    expect{ subject.from_const(0.0 / 0.0) }.to raise_error(Z3::Exception)
-  end
+    it "raises exception when trying to convert constants of wrong type" do
+      expect{ subject.from_const(true) }.to raise_error(Z3::Exception)
+      expect{ subject.from_const(false) }.to raise_error(Z3::Exception)
+      expect{ subject.from_const(1.0 / 0.0) }.to raise_error(Z3::Exception)
+      expect{ subject.from_const(-1.0 / 0.0) }.to raise_error(Z3::Exception)
+      expect{ subject.from_const(0.0 / 0.0) }.to raise_error(Z3::Exception)
+    end
 
-  it "can instantiate variables" do
-    expect(Z3.Real("a").inspect).to eq("Real<a>")
+    it "can instantiate variables" do
+      expect(Z3.Real("a").inspect).to eq("Real<a>")
+    end
   end
 end

data/spec/rounding_mode_expr_spec.rb

@@ -0,0 +1,16 @@
+module Z3
+  describe RoundingModeExpr do
+    let(:sort) { RoundingModeSort.new }
+    let(:a) { sort.var("a") }
+
+    it "list all possible options" do
+      expect([a == a]).to have_solutions([
+        { a => sort.nearest_ties_away },
+        { a => sort.nearest_ties_even },
+        { a => sort.towards_zero },
+        { a => sort.towards_negative },
+        { a => sort.towards_positive },
+      ])
+    end
+  end
+end