cudd-rb 0.0.1

data/spec/interfaces/bdd/test_is_complement.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+module Cudd
+  describe Interface::BDD, 'is_complement' do
+
+    context 'on ZERO' do
+      subject{ zero.is_complement? }
+      it{ should be_true }
+    end
+
+    context 'on ONE' do
+      subject{ one.is_complement? }
+      it{ should be_false }
+    end
+
+    context 'on x' do
+      subject{ x.is_complement? }
+      it{ should be_false }
+    end
+
+    context 'on !x' do
+      subject{ !x.is_complement? }
+      it{ should be_true }
+    end
+
+  end
+end

data/spec/interfaces/bdd/test_ite.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+module Cudd
+  describe Interface::BDD, 'ite' do
+
+    subject{ bdd_interface.ite(x,y,z) }
+
+    it_behaves_like "a BDD"
+
+    it 'is equal (x & y) | (!x & z)' do
+      subject.should eq((x & y) | (!x & z))
+    end
+
+    it 'is equal to x.ite(y, z)' do
+      subject.should eq(x.ite(y,z))
+    end
+
+  end
+end

data/spec/interfaces/bdd/test_ith_var.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+module Cudd
+  describe Interface::BDD, 'ith_var' do
+
+    subject{ bdd_interface.ith_var(1) }
+
+    it_behaves_like "a BDD"
+
+    it 'has the correct index' do
+      subject.var_index.should eq(1)
+    end
+
+    it 'is not one' do
+      subject.should_not be_one
+    end
+
+    it 'is not zero' do
+      subject.should_not be_zero
+    end
+
+    it 'is equal to itself' do
+      subject.should eq(bdd_interface.ith_var(1))
+    end
+
+    it 'is not equal to another one' do
+      subject.should_not eq(bdd_interface.ith_var(0))
+    end
+
+    it 'is satisfiable and not a tautology' do
+      subject.should be_satisfiable
+      subject.should_not be_tautology
+    end
+  end
+end

data/spec/interfaces/bdd/test_ith_vars.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+module Cudd
+  describe Interface::BDD, 'ith_vars' do
+
+    subject{ bdd_interface.ith_vars(*Array(arg)) }
+
+    context "with a single Integer" do
+      let(:arg){ 2 }
+
+      it 'returns [ z ]' do
+        subject.should eq([ z ])
+      end
+    end
+
+    context "with multiple Integers" do
+      let(:arg){ [ 0, 2 ] }
+
+      it 'returns [ x, z ]' do
+        subject.should eq([ x, z ])
+      end
+    end
+
+    context "with multiple Integers in an Array" do
+      let(:arg){ [[ 0, 2 ]] }
+
+      it 'returns [ x, z ]' do
+        subject.should eq([ x, z ])
+      end
+    end
+
+    context "with multiple Integers in a Range" do
+      let(:arg){ 0..1 }
+
+      it 'returns [ x, y ]' do
+        subject.should eq([ x, y ])
+      end
+    end
+
+  end
+end

data/spec/interfaces/bdd/test_new_var.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+module Cudd
+  describe Interface::BDD, 'new_var' do
+
+    context 'without argument' do
+      subject{ bdd_interface.new_var }
+
+      it_behaves_like "a BDD"
+
+      it 'has the last index' do
+        next_index = bdd_interface.size
+        subject.var_index.should eq(next_index)
+      end
+
+      it 'has a default name' do
+        subject.var_name.should eq(:"v#{subject.var_index}")
+      end
+    end
+
+    context 'with a name as argument' do
+      subject{ bdd_interface.new_var(:foo) }
+
+      it_behaves_like "a BDD"
+
+      it 'has the last index' do
+        next_index = bdd_interface.size
+        subject.var_index.should eq(next_index)
+      end
+
+      it 'has the provided name' do
+        subject.var_name.should eq(:foo)
+      end
+    end
+
+  end
+end

data/spec/interfaces/bdd/test_new_vars.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+module Cudd
+  describe Interface::BDD, 'new_vars' do
+
+    context "with a number of variables" do
+      subject{ bdd_interface.new_vars(5) }
+
+      it 'returns an Array of 5 BDDs' do
+        subject.should be_a(Array)
+        subject.size.should eq(5)
+        subject.each{|bdd| bdd.should be_a(Cudd::BDD) }
+      end
+
+      it 'returns 5 variables of different indexes' do
+        start = bdd_interface.size
+        subject.map(&:index).should eq((start...start+5).to_a)
+      end
+    end
+
+    context 'with a single name' do
+      subject{ bdd_interface.new_vars(:foo) }
+
+      it 'returns an Array of 1 BDD with correct name' do
+        subject.map(&:var_name).should eq([:foo])
+      end
+    end
+
+    context 'with an array of names' do
+      subject{ bdd_interface.new_vars([:foo, :bar]) }
+
+      it 'returns an array of 2 BDDs with correct names' do
+        subject.map(&:var_name).should eq([:foo, :bar])
+      end
+    end
+
+    context 'with a varargs of names' do
+      subject{ bdd_interface.new_vars(:foo, :bar) }
+
+      it 'returns an array of 2 BDDs with correct names' do
+        subject.map(&:var_name).should eq([:foo, :bar])
+      end
+    end
+
+  end
+end

data/spec/interfaces/bdd/test_not.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+module Cudd
+  describe Interface::BDD, 'not' do
+
+    subject{ bdd_interface.not(x) }
+
+    it_behaves_like "a BDD"
+
+    it 'yields its origin if negated' do
+      bdd_interface.not(subject).should eq(x)
+    end
+
+    it 'is equal to !x' do
+      subject.should eq(!x)
+    end
+
+  end
+end

data/spec/interfaces/bdd/test_one.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+module Cudd
+  describe Interface::BDD, 'one' do
+
+    subject{ one }
+
+    it_behaves_like "a BDD"
+
+    it 'is one' do
+      subject.should be_one
+      subject.true?.should eq(true)
+      subject.should be_tautology
+    end
+
+    it 'is not zero' do
+      subject.should_not be_zero
+      subject.should_not be_contradiction
+      subject.false?.should eq(false)
+    end
+
+    it 'is satisfiable' do
+      subject.should be_satisfiable
+    end
+
+  end
+end

data/spec/interfaces/bdd/test_one_cube.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+module Cudd
+  module Interfaces
+    describe BDD, "one_cube" do
+
+      subject{ formula.one_cube }
+
+      before do
+        formula.ref
+        subject.should be_a(Cube)
+      end
+
+      after do
+        formula.deref if formula
+      end
+
+      context 'on (x & y)' do
+        let(:formula){ x & y }
+      
+        it 'returns an assignment x => true & y => true' do
+          subject.should eq(cube(x => true, y => true))
+        end
+      end
+      
+      context 'on (x | y)' do
+        let(:formula){ x | y }
+      
+        it 'returns a bdd satisfied by x => false, y => true' do
+          subject.should eq(cube(x => false, y => true))
+        end
+      end
+
+    end
+  end
+end

data/spec/interfaces/bdd/test_or.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Cudd
+  describe Interface::BDD, 'or' do
+
+    subject{ bdd_interface.or(x,y) }
+
+    it_behaves_like "a BDD"
+
+    it 'is equal to (x | y)' do
+      subject.should eq(x | y)
+    end
+
+  end
+end

data/spec/interfaces/bdd/test_restrict.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+module Cudd
+  describe Interface::BDD, 'restrict' do
+
+    subject{ f.restrict(g) }
+
+    context 'when g is a cube' do
+      let(:f){ x & y   }
+      let(:g){ {x => true} }
+
+      it_behaves_like "a BDD"
+
+      it{ should eq(f.cofactor(g)) }
+    end
+
+    context 'when it is a complex bdd' do
+      let(:f){ (x & y) | z }
+      let(:g){ x.xor(y)    }
+
+      it_behaves_like "a BDD"
+
+      it { should eq(z) }
+    end
+
+  end
+end

data/spec/interfaces/bdd/test_satisfiable.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+module Cudd
+  describe Interface::BDD, 'satisfiable?' do
+
+    subject{ bdd.satisfiable? }
+
+    context 'on ZERO' do
+      let(:bdd){ zero }
+      it{ should be_false }
+    end
+
+    context 'on ONE' do
+      let(:bdd){ one }
+      it{ should be_true }
+    end
+
+    context 'on a variable' do
+      let(:bdd){ x }
+      it{ should be_true }
+    end
+
+    context 'on a satisfiable formula' do
+      let(:bdd){ x & y }
+      it{ should be_true }
+    end
+
+    context 'on a non satisfiable formula' do
+      let(:bdd){ x & !x }
+      it{ should be_false }
+    end
+
+  end
+end

data/spec/interfaces/bdd/test_satisfied.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+module Cudd
+  describe Interface::BDD, 'satisfied?' do
+
+    let(:assignment){ { x => true, y => false } }
+
+    subject{ bdd.satisfied?(assignment) }
+
+    context 'on ZERO' do
+      let(:bdd){ zero }
+      it{ should be_false }
+    end
+
+    context 'on ONE' do
+      let(:bdd){ one }
+      it{ should be_true }
+    end
+
+    context 'on the variable x' do
+      let(:bdd){ x }
+      it{ should be_true }
+    end
+
+    context 'on the variable y' do
+      let(:bdd){ y }
+      it{ should be_false }
+    end
+
+    context 'on a non satisfied formula' do
+      let(:bdd){ x & y }
+      it{ should be_false }
+    end
+
+    context 'on a satisfied formula' do
+      let(:bdd){ x | y }
+      it{ should be_true }
+    end
+
+  end
+end

data/spec/interfaces/bdd/test_size.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+module Cudd
+  describe Interface::BDD, 'size' do
+
+    after do
+      interface.close if interface
+    end
+    subject{ interface.size }
+
+    context 'when built without size' do
+      let(:interface){ Cudd.manager.interface(:BDD) }
+
+      it 'starts at zero by default' do
+        subject.should eq(0)
+      end
+
+      it 'counts the number of declared variables' do
+        interface.new_var
+        interface.new_var
+        subject.should eq(2)
+      end
+    end
+
+    context 'when built with an initialize bdd size' do
+      let(:interface){ Cudd.manager(:numVars => 10).interface(:BDD) }
+
+      it 'starts at ten by default' do
+        subject.should eq(10)
+      end
+    end
+
+  end
+end

data/spec/interfaces/bdd/test_support.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+module Cudd
+  module Interfaces
+    describe BDD, "support" do
+
+      subject{ formula.support }
+
+      before do
+        formula.ref
+      end
+
+      after do
+        formula.deref if formula
+      end
+
+      context "on ZERO" do
+        let(:formula){ zero }
+
+        it 'returns ONE' do
+          subject.should eq(one)
+        end
+      end
+
+      context "on ONE" do
+        let(:formula){ one }
+
+        it 'returns ONE' do
+          subject.should eq(one)
+        end
+      end
+
+      context "on x" do
+        let(:formula){ x }
+
+        it 'returns x' do
+          subject.should eq(x)
+        end
+      end
+
+      context "on !x" do
+        let(:formula){ !x }
+
+        it 'returns x' do
+          subject.should eq(x)
+        end
+      end
+
+      context 'on (x & y)' do
+        let(:formula){ x & y }
+
+        it 'returns x & y' do
+          subject.should eq(x & y)
+        end
+      end
+
+      context 'on (x | !y)' do
+        let(:formula){ x | !y }
+
+        it 'returns x & y' do
+          subject.should eq(x & y)
+        end
+      end
+
+    end
+  end
+end

data/spec/interfaces/bdd/test_var_index.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+module Cudd
+  describe Interface::BDD, 'var_index' do
+
+    it 'returns nil on zero' do
+      zero.var_index.should be_nil
+    end
+
+    it 'returns nil on one' do
+      one.var_index.should be_nil
+    end
+
+    it 'returns 0 on x' do
+      x.var_index.should eq(0)
+    end
+
+    it 'returns 1 on y' do
+      y.var_index.should eq(1)
+    end
+
+    it 'returns 2 on z' do
+      z.var_index.should eq(2)
+    end
+
+  end
+end

data/spec/interfaces/bdd/test_var_name.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+module Cudd
+  describe Interface::BDD, 'var_name' do
+
+    subject{ bdd_interface.var_name(bdd) }
+
+    context 'on zero' do
+      let(:bdd){ zero }
+
+      it{ should eq(:zero) }
+    end
+
+    context 'on one' do
+      let(:bdd){ one }
+
+      it{ should eq(:one) }
+    end
+
+    context 'on an unnamed variable' do
+      let(:bdd){ x }
+      
+      it { should eq(:v0) }
+    end
+
+    context 'on an named variable' do
+      let(:bdd){ bdd_interface.new_var(:foo) }
+      
+      it { should eq(:foo) }
+    end
+
+  end
+end

data/spec/interfaces/bdd/test_var_names.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+module Cudd
+  describe Interface::BDD, 'var_names' do
+
+    subject{ bdd_interface.var_names }
+
+    context 'when no variables have been declared at all' do
+      it{ should eq([]) }
+    end
+
+    context 'when some variables have been declared but not named' do
+      before{ x; y }
+      it{ should eq([ :v0, :v1 ]) }
+    end
+
+    context 'when some variables have even been named' do
+      before{ 
+        x; y
+        bdd_interface.var_names = [ :x ]
+      }
+      it{ should eq([ :x, :v1 ]) }
+    end
+
+  end
+end

data/spec/interfaces/bdd/test_zero.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+module Cudd
+  describe Interface::BDD, 'zero' do
+
+    subject{ zero }
+
+    it_behaves_like "a BDD"
+
+    it 'is zero' do
+      subject.should be_zero
+      subject.should be_contradiction
+      subject.false?.should eq(true)
+    end
+
+    it 'is not one' do
+      subject.should_not be_one
+      subject.true?.should eq(false)
+      subject.should_not be_tautology
+    end
+
+    it 'is not satisfiable' do
+      subject.should_not be_satisfiable
+    end
+
+  end
+end

data/spec/manager/test_interface.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+module Cudd
+  describe Manager, "#interface" do
+
+    it 'serves itself as Root interface' do
+      with_manager do |m|
+        i = m.interface(:Root)
+
+        i.should be_a(Manager)
+        i.should be_root_manager
+
+        i.should be_a(Interface::Root)
+        i.should eq(m)
+      end
+    end
+
+    it 'serves the BDD interface without error' do
+      with_manager do |m|
+        manager = m
+        i = m.interface(:BDD)
+
+        i.should be_a(Manager)
+        i.should_not be_root_manager
+
+        i.should be_a(Interface::Root)
+        i.should be_a(Interface::BDD)
+      end
+    end
+
+    it 'always serves the same Root' do
+      with_manager do |m|
+        root1 = m.interface(:Root)
+        bdd1  = m.interface(:BDD)
+        bdd1.interface(:Root).should eq(root1)
+      end
+    end
+
+    it 'always serves the same names interface' do
+      with_manager do |m|
+        bdd1 = m.interface(:BDD)
+        bdd2 = m.interface(:BDD)
+        bdd3 = bdd1.interface(:BDD)
+        bdd1.should eq(bdd2)
+        bdd2.should eq(bdd3)
+      end
+    end
+
+  end
+end

data/spec/shared/a_bdd.rb

@@ -0,0 +1,15 @@
+shared_examples_for "a BDD" do
+
+  it 'is a FFI::Pointer' do
+    subject.should be_a(FFI::Pointer)
+  end
+
+  it 'includes the Cudd::BDD module' do
+    subject.should be_a(Cudd::BDD)
+  end
+
+  it 'has a manager, which is a Cudd::Manager' do
+    subject.manager.should be_a(Cudd::Manager)
+  end
+
+end