art-decomp 0.0.0

data/spec/art-decomp/bipainter_spec.rb

@@ -0,0 +1,22 @@
+module ArtDecomp describe Bipainter do
+
+  context 'when used for generating the Qv and G blankets' do
+
+    # FIXME: add more specs, targeting non-trivial cases
+
+    it 'should colour the two incompatibility graphs properly and return the resulting blankets' do
+      beta_q = Blanket[B[1,2], B[3,4], B[5,6]]
+      beta_v = Blanket[B[1,3,5], B[2,4,6]]
+      seps   = Set[Sep[1,2], Sep[1,3], Sep[1,6], Sep[2,6], Sep[3,4], Sep[3,6], Sep[4,5], Sep[5,6]]
+
+      bipainter = Bipainter.new beta_q, beta_v, seps
+      bipainter.blankets.should == [Blanket[B[1,2], B[3,4,5,6]], Blanket[B[1], B[2,3,5], B[4,6]]]
+    end
+
+    it 'should raise a RuntimeError on non-disjoint beta_v' do
+      lambda { Bipainter.new Blanket[], Blanket[B[0,1], B[0,2]], Set[] }.should raise_error(RuntimeError, 'non-disjoint beta_v')
+    end
+
+  end
+
+end end

data/spec/art-decomp/blanket_spec.rb

@@ -0,0 +1,77 @@
+# encoding: UTF-8
+
+module ArtDecomp describe Blanket do
+
+  it 'should be easily instantiable, properly comparable and usable as a Set element' do
+    Blanket[B[], B[0], B[1,2]].should      == Blanket.new([B[1,2], B[0]])
+    Blanket[B[], B[0], B[1,2]].hash.should == Blanket.new([B[1,2], B[0]]).hash
+    Blanket[B[], B[0], B[1,2]].should     eql Blanket.new([B[1,2], B[0]])
+  end
+
+  it 'should expose its internal ints variable and it should be immutable' do
+    Blanket[B[1,2], B[3,4]].ints.should == Set[B[3,4], B[1,2]]
+    Blanket[B[1,2], B[3,4]].ints.should be_frozen
+  end
+
+  it 'should be properly instantiable from an Array' do
+      blanket = Blanket.from_array [:b, DontCare, :a, :c, :b, :a, :c]
+      blanket.should == Blanket[B[0,1,4], B[1,2,5], B[1,3,6]]
+  end
+
+  it 'should be inspectable and return a self-instanting form' do
+    Blanket[B[]].inspect.should == 'Blanket[]'
+    Blanket[B[1,2], B[0]].inspect.should == 'Blanket[B[0], B[1,2]]'
+  end
+
+  it 'should be multipliable by other Blankets' do
+    b1 = Blanket[B[1,2,3], B[4,5,6]]
+    b2 = Blanket[B[1,2], B[3,4], B[5,6]]
+    (b1 * b2).should == Blanket[B[1,2], B[3], B[4], B[5,6]]
+  end
+
+  it 'should properly expose the separations it provides/requires' do
+    Blanket[].seps.should                   == Set[]
+    Blanket[B[1]].seps.should               == Set[]
+    Blanket[B[1], B[2], B[]].seps.should    == Set[Sep[1,2]]
+    Blanket[B[1,2], B[3,4]].seps.should     == Set[Sep[1,3], Sep[1,4], Sep[2,3], Sep[2,4]]
+    Blanket[B[1,2,3], B[2,3,4]].seps.should == Set[Sep[1,4]]
+  end
+
+  it 'should properly report its size' do
+    Blanket[].size.should                   == 0
+    Blanket[B[1]].size.should               == 1
+    Blanket[B[1], B[2], B[]].size.should    == 2
+    Blanket[B[1,2,3], B[2,3,4]].size.should == 2
+  end
+
+  it 'should return the Blanket’s ‘natural’ encoding, based on the provided subblock' do
+    blanket = Blanket[B[0,1,2], B[1,2,3], B[2,3,4]]
+    blanket.encoding(B[0,1,2]).should == '00'
+    blanket.encoding(B[1,2,3]).should == '01'
+    blanket.encoding(B[2,3,4]).should == '10'
+    blanket.encoding(B[2]).should     == '--'
+    lambda { blanket.encoding(B[1,2]) }.should raise_error(AmbiguousEncodingQuery, 'ambiguous encoding query: block 1,2')
+  end
+
+  it 'should return the Blanket’s ‘natural’ encodings in an Array if so asked' do
+    blanket = Blanket[B[0,1,2], B[1,2,3], B[2,3,4]]
+    blanket.encodings(B[0,1,2]).should == ['00']
+    blanket.encodings(B[1,2,3]).should == ['01']
+    blanket.encodings(B[2,3,4]).should == ['10']
+    blanket.encodings(B[2]).should     == ['--']
+    blanket.encodings(B[1,2]).should   == ['00', '01']
+  end
+
+  it 'should report how many physical pins it uses' do
+    Blanket[B[]].pins.should                                          == 0
+    Blanket[B[1]].pins.should                                         == 0
+    Blanket[B[1,2]].pins.should                                       == 0
+    Blanket[B[1],B[2]].pins.should                                    == 1
+    Blanket[B[1],B[2],B[3]].pins.should                               == 2
+    Blanket[B[1,2],B[3,4],B[5,6],B[7]].pins.should                    == 2
+    Blanket[B[1],B[2],B[3],B[4],B[5]].pins.should                     == 3
+    Blanket[B[1],B[2],B[3],B[4],B[5],B[6],B[7],B[8]].pins.should      == 3
+    Blanket[B[1],B[2],B[3],B[4],B[5],B[6],B[7],B[8],B[9]].pins.should == 4
+  end
+
+end end

data/spec/art-decomp/decomposer_spec.rb

@@ -0,0 +1,106 @@
+module ArtDecomp describe Decomposer do
+
+  it 'should instantiate itself and its components properly' do
+    fsm      = mock FSM
+    archs    = Set[Arch[5,1], Arch[4,2]]
+    uv1, uv2 = mock('UVGenerator class'), mock('UVGenerator class')
+    qu1, qu2 = mock('QuGenerator class'), mock('QuGenerator class')
+    qv1, qv2 = mock('QvGenerator class'), mock('QvGenerator class')
+    [uv1, uv2].each           { |gen| gen.should_receive(:new).with fsm, archs }
+    [qu1, qu2, qv1, qv2].each { |gen| gen.should_receive(:new).with no_args }
+    Decomposer.new :fsm => fsm, :archs => archs, :uv_gens => [uv1, uv2], :qu_gens => [qu1, qu2], :qv_gens => [qv1, qv2]
+  end
+
+  context 'given that the three generators are working properly' do
+
+    class StubGenerator
+      def initialize sequences
+        @sequences = sequences
+      end
+      def elems *key, &block
+        @sequences[key].each &block
+      end
+      alias uv_pairs elems
+      alias blankets elems
+    end
+
+    it 'should poll the generators and yield the resulting decompositions one by one' do
+      fsm = mock FSM, :beta_q => mock(Blanket, :pins => 3, :size => 5), :input_count => 4
+
+      u_a, v_a = Set[0,1], Set[2] # for this U/V pair: two Qu generating one Qv/G pair each
+      qu_a1, qv_a1, g_a1 = mock(Blanket, :pins => 2, :size => 4), mock(Blanket, :pins => 3, :size => 5), mock(Blanket, :pins => 2)
+      qu_a2, qv_a2, g_a2 = mock(Blanket, :pins => 2, :size => 4), mock(Blanket, :pins => 3, :size => 5), mock(Blanket, :pins => 2)
+
+      u_b, v_b = Set[0], Set[1,2] # for this U/V pair: one Qu generating two Qv/G pairs
+      qu_b = mock Blanket, :pins => 2, :size => 4
+      qv_bA, g_bA = mock(Blanket, :pins => 3, :size => 5), mock(Blanket, :pins => 2)
+      qv_bB, g_bB = mock(Blanket, :pins => 3, :size => 5), mock(Blanket, :pins => 2)
+
+      uv_gen = mock UVGenerator, :new => StubGenerator.new({[] => [[fsm, u_a, v_a], [fsm, u_b, v_b]]})
+      qu_gen = mock QuGenerator, :new => StubGenerator.new({[fsm, u_a, v_a] => [qu_a1, qu_a2],
+                                                            [fsm, u_b, v_b] => [qu_b]})
+      qv_gen = mock QvGenerator, :new => StubGenerator.new({[fsm, u_a, v_a, qu_a1] => [[qv_a1, g_a1]],
+                                                            [fsm, u_a, v_a, qu_a2] => [[qv_a2, g_a2]],
+                                                            [fsm, u_b, v_b, qu_b]  => [[qv_bA, g_bA], [qv_bB, g_bB]]})
+
+      decomposer = Decomposer.new :archs => Set[Arch[5,1]], :fsm => fsm, :uv_gens => [uv_gen], :qu_gens => [qu_gen], :qv_gens => [qv_gen]
+      results = decomposer.decompositions.to_a
+      results.size.should  == 4
+      results.first.should == Decomposition.new(fsm, u_a, v_a, qu_a1, qv_a1, g_a1)
+      results.last.should  == Decomposition.new(fsm, u_b, v_b, qu_b,  qv_bB, g_bB)
+    end
+
+    it 'should yield only sensible decompositions' do
+      fsm    = mock FSM
+      uv_gen = mock UVGenerator,   :uv_pairs  => [[fsm, Set[0], Set[1]]]
+      qu_gen = mock QuGenerator,   :blankets  => [mock(Blanket)]
+      qv_gen = mock QvGenerator,   :blankets  => [[mock(Blanket), mock(Blanket)], [mock(Blanket), mock(Blanket)]]
+      dec1   = mock Decomposition, :sensible? => true
+      dec2   = mock Decomposition, :sensible? => false
+      Decomposition.should_receive(:new).exactly(2).times.and_return dec1, dec2
+      decomposer = Decomposer.new :fsm => fsm, :uv_gens => [mock('UVG', :new => uv_gen)], :qu_gens => [mock('QuG', :new => qu_gen)], :qv_gens => [mock('QvG', :new => qv_gen)]
+      decomposer.decompositions.to_a.should == [dec1]
+    end
+
+    it 'should skip re-computing elements it already computed once (unless told not to)' do
+      qu1, qu2, qv, g1, g2 = mock(Blanket), mock(Blanket), mock(Blanket), mock(Blanket), mock(Blanket)
+      fsm    = mock FSM
+      uv_gen = mock UVGenerator, :uv_pairs => [[fsm, Set[0], Set[1]], [fsm, Set[0], Set[1]], [fsm, Set[1], Set[0]]]
+      qu_gen = mock QuGenerator, :blankets => [qu1, qu1, qu2]
+      qv_gen = mock QvGenerator, :blankets => [[qv, g1], [qv, g1], [qv, g2]]
+      dec    = mock Decomposition, :sensible? => true
+      Decomposition.should_receive(:new).exactly(8).times.and_return dec
+      decomposer = Decomposer.new :fsm => fsm, :uv_gens => [mock('UVG', :new => uv_gen)], :qu_gens => [mock('QuG', :new => qu_gen)], :qv_gens => [mock('QvG', :new => qv_gen)]
+      decomposer.decompositions.to_a.size.should == 8
+      Decomposition.should_receive(:new).exactly(27).times.and_return dec
+      decomposer = Decomposer.new :fsm => fsm, :uv_gens => [mock('UVG', :new => uv_gen)], :qu_gens => [mock('QuG', :new => qu_gen)], :qv_gens => [mock('QvG', :new => qv_gen)]
+      decomposer.decompositions(:keep_seen => true).to_a.size.should == 27
+    end
+
+    it 'should compute shallow ((u & v).size == 1) non-disjoint decompositions (if told to)' do
+      qu, qv, g1, g2 = mock(Blanket), mock(Blanket), mock(Blanket, :pins => 1), mock(Blanket, :pins => 2)
+      fsm    = mock FSM
+      uv_gen = mock UVGenerator, :uv_pairs => [[fsm, Set[0,1], Set[2,3]]]
+      qu_gen = mock QuGenerator, :blankets => [qu]
+      qv_gen = mock QvGenerator, :blankets => [[qv, g2], [qv, g1]]
+      dec    = mock Decomposition, :sensible? => true
+      Decomposition.should_receive(:new).exactly(6).times.and_return dec
+      decomposer = Decomposer.new :fsm => fsm, :uv_gens => [mock('UVG', :new => uv_gen)], :qu_gens => [mock('QuG', :new => qu_gen)], :qv_gens => [mock('QvG', :new => qv_gen)]
+      decomposer.decompositions(:non_disjoint => true).to_a.size.should == 4
+    end
+
+    it 'should compute deep ((u & v).size > 1) non-disjoint decompositions (if told to)' do
+      qu, qv, g1, g2 = mock(Blanket), mock(Blanket), mock(Blanket, :pins => 1), mock(Blanket, :pins => 2)
+      fsm    = mock FSM
+      uv_gen = mock UVGenerator, :uv_pairs => [[fsm, Set[0,1], Set[2,3]]]
+      qu_gen = mock QuGenerator, :blankets => [qu]
+      qv_gen = mock QvGenerator, :blankets => [[qv, g2], [qv, g1]]
+      dec    = mock Decomposition, :sensible? => true
+      Decomposition.should_receive(:new).exactly(8).times.and_return dec
+      decomposer = Decomposer.new :fsm => fsm, :uv_gens => [mock('UVG', :new => uv_gen)], :qu_gens => [mock('QuG', :new => qu_gen)], :qv_gens => [mock('QvG', :new => qv_gen)]
+      decomposer.decompositions(:non_disjoint => true, :deep_ndj => true).to_a.size.should == 4
+    end
+
+  end
+
+end end

data/spec/art-decomp/decomposition_spec.rb

@@ -0,0 +1,119 @@
+# encoding: UTF-8
+
+module ArtDecomp describe Decomposition do
+
+  it 'should instantiate, compare and hash properly' do
+    fsm = mock FSM
+    u, v = Set[0,1], Set[2]
+    qu, qv, g = mock(Blanket), mock(Blanket), mock(Blanket)
+    dec = Decomposition.new fsm, u, v, qu, qv, g
+    dec.should      == Decomposition.new(fsm, u, v, qu, qv, g)
+    dec.should_not  == Decomposition.new(fsm, v, u, qu, qv, g)
+    dec.should_not  == Decomposition.new(fsm, u, v, qv, qu, g)
+    dec.hash.should == Decomposition.new(fsm, u, v, qu, qv, g).hash
+    dec.should     eql Decomposition.new(fsm, u, v, qu, qv, g)
+  end
+
+  it 'should create its F, Q, G and H blocks’ KISS representations properly' do
+    fsm = FSM.from_kiss 'spec/fixtures/fsm'
+    qu  = Blanket[B[0,4,5], B[1,2,3,13,14], B[6,7,8,9,10,11,12], B[15,16,17,18,19]]
+    qv  = Blanket[B[0,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,19], B[1,2,18]]
+    g   = Blanket[B[0,2,5,6,7,9,11,15,16,17,18,19], B[1,3,4,8,10,12,13,14]]
+    decomposition = Decomposition.new fsm, Set[0,1,3], Set[2], qu, qv, g
+    decomposition.f_kiss.should == File.read('spec/fixtures/fsm.f')
+    decomposition.q_kiss.should == File.read('spec/fixtures/fsm.q')
+    decomposition.g_kiss.should == File.read('spec/fixtures/fsm.g')
+    decomposition.h_kiss.should == File.read('spec/fixtures/fsm.h')
+  end
+
+  it 'should create the H block properly, even if the G blanket seems ambiguous' do
+    fsm = FSM.from_kiss 'spec/fixtures/opus'
+    qu  = Blanket[B[0,1,11,14,15,16,17,18,19,20,30,33,34,35,36,37], B[2,5,7,14,21,24,26,33], B[3,4,10,13,14,22,23,29,32,33], B[6,8,9,12,14,25,27,28,31,33]]
+    qv  = Blanket[B[0,2,6,8,10,13,14,15,19,21,25,27,29,32,33,34], B[1,3,4,5,7,9,12,14,20,22,23,24,26,28,31,33], B[11,14,16,17,18,30,33,35,36,37]]
+    g   = Blanket[B[0,2,6,8,10,13,14,15,19,21,25,27,29,32,33,34], B[1,3,4,5,7,9,12,14,20,22,23,24,26,28,31,33], B[11,14,16,17,18], B[30,33,35,36,37]]
+    decomposition = Decomposition.new fsm.expand_x(Set[0]), Set[1,2,3,4], Set[0], qu, qv, g
+    decomposition.h_kiss.should == File.read('spec/fixtures/opus.amb.h')
+  end
+
+  it 'should properly recode don’t-care states to *' do
+    fsm = FSM.from_kiss 'spec/fixtures/opus'
+    qu  = Blanket[B[0,1,2,3,4,20,21], B[0,5,6,7], B[0,8,9,10,11,12,13,14,15,16], B[0,17,18,19]]
+    qv  = Blanket[B[0,1,2,6,7,15,16,17,18], B[0,3,4,5,8,9,10,11,12,13,14,19], B[0,20,21]]
+    g   = Blanket[B[0,1], B[2,6,7,15,16,17,18], B[3,4,5,8,9,10,11,12,13,14,19], B[20,21]]
+    decomposition = Decomposition.new fsm, Set[0,1,3,4], Set[2], qu, qv, g
+    decomposition.h_kiss.should == File.read('spec/fixtures/opus.h')
+  end
+
+  it 'should properly report whether it’s valid' do
+    fsm = FSM.from_kiss 'spec/fixtures/fsm'
+    qu  = Blanket[B[0,1,2,3,4,5,17], B[6,7,8,9,10,11,12,13,14,15,16,18,19]]
+    qv  = Blanket[B[0,1,2,17,19], B[3,6,7,8,9,10,11,12], B[4,5,18], B[13,14,15,16]]
+    g   = Blanket[B[0,1,4,6,17,18,19], B[2,7,9,11], B[3,5,8,10,12], B[13,14,15,16]]
+    Decomposition.new(fsm, Set[1,3], Set[0,2], qu, qv, g).should     be_valid
+    Decomposition.new(fsm, Set[1,3], Set[0,2], qv, qu, g).should_not be_valid
+    Decomposition.new(fsm, Set[1,3], Set[0,2], qv, qv, g).should_not be_valid
+  end
+
+  it 'should report whether it’s disjoint' do
+    fsm = mock FSM
+    b   = mock Blanket
+    Decomposition.new(fsm, Set[0],   Set[1],   b, b, b).should     be_disjoint
+    Decomposition.new(fsm, Set[0,1], Set[1],   b, b, b).should_not be_disjoint
+    Decomposition.new(fsm, Set[1],   Set[0,1], b, b, b).should_not be_disjoint
+  end
+
+  context 'when assesing whether it’s usable in the future' do
+
+    before do
+      @fsm = mock FSM, :beta_q => mock(Blanket, :pins => 3), :input_count => 3, :output_count => 2
+      @b   = mock Blanket
+      @b1  = mock Blanket, :pins => 1, :size => 2
+      @b2  = mock Blanket, :pins => 2, :size => 4
+      @b3  = mock Blanket, :pins => 3
+      @b4  = mock Blanket, :pins => 4
+    end
+
+    it 'should properly report whether it’s decomposable further' do
+      Decomposition.new(@fsm, Set[0], Set[1], @b1, @b, @b).should_not be_decomposable
+      Decomposition.new(@fsm, Set[0], Set[1], @b2, @b, @b).should     be_decomposable
+    end
+
+    it 'should properly report whether it’s sensible, based on the target Archs and G and H blocks’ architectures' do
+      Decomposition.new(@fsm, Set[0],   Set[1,2],   @b2, @b2, @b2).should_not be_sensible Set[Arch[3,2]]
+      Decomposition.new(@fsm, Set[0],   Set[1,2],   @b2, @b2, @b2).should     be_sensible Set[Arch[4,1]]
+      Decomposition.new(@fsm, Set[],    Set[0,1,2], @b2, @b2, @b2).should_not be_sensible Set[Arch[4,1]]
+      Decomposition.new(@fsm, Set[0],   Set[1,2],   @b2, @b3, @b2).should_not be_sensible Set[Arch[4,1]]
+      Decomposition.new(@fsm, Set[0,1], Set[1,2],   @b2, @b2, @b2).should_not be_sensible Set[Arch[4,1]]
+      Decomposition.new(@fsm, Set[0],   Set[1,2],   @b3, @b2, @b2).should_not be_sensible Set[Arch[4,1]]
+      Decomposition.new(@fsm, Set[0],   Set[1,2],   @b2, @b2, @b3).should_not be_sensible Set[Arch[4,1]]
+    end
+
+    it 'should properly report whether it’s final based on a Set of Archs' do
+      Decomposition.new(@fsm, Set[0],   Set[1],   @b1, @b3, @b3).should     be_final Set[Arch[5,1]]
+      Decomposition.new(@fsm, Set[0],   Set[1],   @b1, @b3, @b3).should_not be_final Set[Arch[4,2]]
+      Decomposition.new(@fsm, Set[],    Set[1],   @b1, @b3, @b3).should     be_final Set[Arch[4,2]]
+      Decomposition.new(@fsm, Set[],    Set[1,2], @b1, @b3, @b3).should_not be_final Set[Arch[4,2]]
+      Decomposition.new(@fsm, Set[],    Set[1],   @b1, @b4, @b3).should_not be_final Set[Arch[4,2]]
+      Decomposition.new(@fsm, Set[0],   Set[1,2], @b1, @b3, @b3).should     be_final Set[Arch[5,1]]
+      Decomposition.new(@fsm, Set[0,1], Set[2],   @b1, @b3, @b3).should_not be_final Set[Arch[5,1]]
+      Decomposition.new(@fsm, Set[0],   Set[1,2], @b2, @b3, @b3).should_not be_final Set[Arch[5,1]]
+      Decomposition.new(@fsm, Set[0],   Set[1,2], @b1, @b3, @b4).should_not be_final Set[Arch[5,1]]
+    end
+
+    it 'should properly report G cell count (if G fits the provided Archs)' do
+      Decomposition.new(@fsm, Set[0], Set[1,2], @b, @b2, @b2).g_cells(Set[Arch[5,1]]).should == 2
+      Decomposition.new(@fsm, Set[0], Set[1,2], @b, @b2, @b2).g_cells(Set[Arch[4,2]]).should == 1
+      Decomposition.new(@fsm, Set[0], Set[1,2], @b, @b2, @b2).g_cells(Set[Arch[3,2]]).should be_nil
+      Decomposition.new(@fsm, Set[0], Set[1,2], @b, @b2, @b3).g_cells(Set[Arch[4,2]]).should == 2
+    end
+
+    it 'should properly report H cell count (if G fits the provided Archs)' do
+      Decomposition.new(@fsm, Set[0], Set[1,2], @b1, @b1, @b2).h_cells(Set[Arch[5,1]]).should == 4
+      Decomposition.new(@fsm, Set[0], Set[1,2], @b1, @b1, @b2).h_cells(Set[Arch[4,2]]).should == 2
+      Decomposition.new(@fsm, Set[0], Set[1,2], @b1, @b1, @b2).h_cells(Set[Arch[3,1]]).should be_nil
+      Decomposition.new(@fsm, Set[0], Set[1,2], @b1, @b2, @b2).h_cells(Set[Arch[4,2]]).should == 3
+    end
+
+  end
+
+end end

data/spec/art-decomp/executable_spec.rb

@@ -0,0 +1,161 @@
+# encoding: UTF-8
+
+module ArtDecomp describe Executable do
+
+  before do
+    @orig_stderr = $stderr
+    $stderr = StringIO.new
+    @fsm = 'spec/fixtures/fsm'
+    @dir = "#{Dir.tmpdir}/#{rand.to_s}"
+    @args = ['--archs', '5/1', '--outdir', @dir, @fsm]
+  end
+
+  after do
+    $stderr = @orig_stderr
+    FileUtils.rmtree @dir if Dir.exists? @dir
+  end
+
+  def stderr
+    $stderr.rewind
+    $stderr.read
+  end
+
+  it 'should require an FSM' do
+    lambda { Executable.new([]) }.should raise_error SystemExit
+    stderr.should =~ rex('no FSM given')
+  end
+
+  it 'should require that the FSM exists' do
+    lambda { Executable.new(['bogus']) }.should raise_error SystemExit
+    stderr.should =~ rex('FSM does not exist')
+  end
+
+  it 'should require at least one target Arch' do
+    lambda { Executable.new([@fsm]) }.should raise_error SystemExit
+    stderr.should =~ rex('no architecture given')
+  end
+
+  it 'should require that all architectures are parsable' do
+    args = ['--archs', '5/1', 'a/b', '--outdir', @dir, @fsm]
+    lambda { Executable.new(args) }.should raise_error SystemExit
+    stderr.should =~ rex('archs not in the form of inputs/outputs')
+  end
+
+  it 'should require output directory' do
+    lambda { Executable.new(['--archs', '5/1', '--', @fsm]) }.should raise_error SystemExit
+    stderr.should =~ rex('no output directory given')
+  end
+
+  it 'should require that the output directory does not exist' do
+    lambda { Executable.new(['--archs', '5/1', '--outdir', Dir.tmpdir, @fsm]) }.should raise_error SystemExit
+    stderr.should =~ rex('output directory exists')
+  end
+
+  it 'should require that the output directory is creatable' do
+    Dir.mkdir @dir, 0400
+    subdir = "#{@dir}/#{rand.to_s}"
+    lambda { Executable.new(['--archs', '5/1', '--outdir', subdir, @fsm]) }.should raise_error SystemExit
+    stderr.should =~ rex('output directory cannot be created')
+  end
+
+  it 'should create the output directory' do
+    Dir.exists?(@dir).should be_false
+    Executable.new @args
+    Dir.exists?(@dir).should be_true
+  end
+
+  it 'should validate that the specified UV generator exists' do
+    lambda { Executable.new(@args + ['--uv', 'bogus']) }.should raise_error SystemExit
+    stderr.should =~ rex('no such UV generator')
+  end
+
+  it 'should validate that the specified Qu generator exists' do
+    lambda { Executable.new(@args + ['--qu', 'bogus']) }.should raise_error SystemExit
+    stderr.should =~ rex('no such Qu generator')
+  end
+
+  it 'should validate that the specified Qv generator exists' do
+    lambda { Executable.new(@args + ['--qv', 'bogus']) }.should raise_error SystemExit
+    stderr.should =~ rex('no such Qv generator')
+  end
+
+  it 'should dump the resulting decompositions into a file' do
+    fsm = FSM.from_kiss 'spec/fixtures/fsm'
+    dec = Decomposition.new fsm, Set[0], Set[1], Blanket[B[0],B[1],B[2]], Blanket[], Blanket[]
+
+    decomposer = mock Decomposer, :decompositions => [dec, dec].each
+    Decomposer.should_receive(:new).with(:fsm => fsm, :archs => an_instance_of(Set), :uv_gens => [UVGenerator::Relevance], :qu_gens => [QuGenerator::EdgeLabels], :qv_gens => [QvGenerator::GraphColouring]).and_return decomposer
+
+    Executable.new(@args).run false
+    Marshal.load(File.read("#{@dir}/decompositions")).should == [dec, dec]
+  end
+
+  it 'should create files holding the resulting Decomposition objects and keep track of the best decomposition' do
+    dec0 = Decomposition.new FSM.from_kiss('spec/fixtures/fsm'), Set[0], Set[1], Blanket[B[0],B[1],B[2]], Blanket[], Blanket[]
+    dec1 = Decomposition.new FSM.from_kiss('spec/fixtures/fsm'), Set[1], Set[0], Blanket[B[0],B[1],B[2]], Blanket[], Blanket[]
+    Decomposer.should_receive(:new).and_return mock(Decomposer, :decompositions => [dec0, dec1].each)
+    ex = Executable.new @args
+    ex.best.should be_nil
+    ex.run
+    ex.best.should == 4
+    Marshal.load(File.read("#{@dir}/0.dec")).should == dec0
+    Marshal.load(File.read("#{@dir}/1.dec")).should == dec1
+  end
+
+  it 'should pass all of the requested generators and architectures to the Decomposer, and report on what it’s using when asked' do
+    fsm = mock FSM, :fsm_cells => nil, :implementable_in? => false, :stats => ''
+    FSM.should_receive(:from_kiss).with(@fsm).and_return fsm
+
+    decomposer = mock Decomposer, :decompositions => [].each
+    Decomposer.should_receive(:new).with(:fsm => fsm, :archs => Set[Arch[4,2], Arch[5,1]], :uv_gens => [UVGenerator::Braindead, UVGenerator::Braindead], :qu_gens => [QuGenerator::BlockTable, QuGenerator::EdgeLabels], :qv_gens => [QvGenerator::GraphMerging, QvGenerator::Bipainting]).and_return decomposer
+
+    args = ['--archs', '5/1', '4/2', '--uv', 'Braindead', 'Braindead', '--qu', 'BlockTable', 'EdgeLabels', '--qv', 'GraphMerging', 'Bipainting', '--outdir', @dir, @fsm]
+    ex = Executable.new args
+    ex.gens.should == 'Braindead+Braindead, BlockTable+EdgeLabels, GraphMerging+Bipainting'
+    ex.run
+  end
+
+  it 'should allow setting any of the generators to ‘all’' do
+    fsm = mock FSM, :fsm_cells => nil, :implementable_in? => false, :stats => ''
+    FSM.should_receive(:from_kiss).with(@fsm).and_return fsm
+
+    decomposer = mock Decomposer, :decompositions => [].each
+    Decomposer.should_receive(:new).with(:fsm => fsm, :archs => Set[Arch[5,1]], :uv_gens => [UVGenerator::Braindead, UVGenerator::Relevance], :qu_gens => [QuGenerator::BlockTable, QuGenerator::EdgeLabels], :qv_gens => [QvGenerator::Bipainting, QvGenerator::GraphColouring,QvGenerator::GraphMerging]).and_return decomposer
+
+    args = ['--archs', '5/1', '--uv', 'all', '--qu', 'all', '--qv', 'all', '--outdir', @dir, @fsm]
+    Executable.new(args).run
+  end
+
+  it 'should decompose iteratively according to the number of iterations and expose this number (along with archs and dir)' do
+    args = ['--archs', '2/1', '--iters', '2', '--outdir', @dir, 'spec/fixtures/lion']
+    dec = Decomposition.new FSM.from_kiss('spec/fixtures/lion'), Set[0], Set[1], Blanket[B[0],B[1],B[2]], Blanket[], Blanket[]
+    Decomposer.stub!(:new).and_return mock(Decomposer, :decompositions => [dec].each)
+    ex = Executable.new args
+    ex.archs.should == Set[Arch[2,1]]
+    ex.iters.should == 2
+    ex.dir.should   == @dir
+    ex.run
+    File.exists?("#{@dir}/0.dec").should     be_true
+    File.exists?("#{@dir}/0/0.dec").should   be_true
+    File.exists?("#{@dir}/0/0/0.dec").should be_false
+  end
+
+  it 'should allow logging to the specified file/stream' do
+    log = Tempfile.new rand
+    Decomposer.should_receive(:new).and_return mock(Decomposer, :decompositions => [].each)
+    Executable.new(['--archs', '5/1', '4/2', '--debug', '--log', log.path, '--outdir', @dir, @fsm]).run
+    Logging.level.should == Logger::DEBUG
+    Logging.off
+    File.read(log.path).should =~ rex('FSM 4/2+10s → 5/1+4/2')
+  end
+
+  it 'should handle the s8 edge case with grace' do
+    log = Tempfile.new rand
+    Executable.new(['--archs', '2/1', '--log', log.path, '--outdir', @dir, 'spec/fixtures/s8']).run
+    Logging.off
+    File.read(log.path).should =~ rex('final best decomposition: 0 cells')
+  end
+
+  # FIXME: add specs for --non-disjoint and --deep-ndj
+
+end end

data/spec/art-decomp/fsm_spec.rb

@@ -0,0 +1,146 @@
+# encoding: UTF-8
+
+module ArtDecomp describe FSM do
+
+  context 'parsed from an example KISS file' do
+
+    before do
+      @fsm   = FSM.from_kiss 'spec/fixtures/fsm'
+      @lion  = FSM.from_kiss 'spec/fixtures/lion'
+      @mark1 = FSM.from_kiss 'spec/fixtures/mark1'
+      @mc    = FSM.from_kiss 'spec/fixtures/mc'
+      @opus  = FSM.from_kiss 'spec/fixtures/opus'
+      @s8    = FSM.from_kiss 'spec/fixtures/s8'
+      @s420  = FSM.from_kiss 'spec/fixtures/s420'
+    end
+
+    it 'should parse both KISS files and strings' do
+      @mc.should == FSM.from_kiss(File.read 'spec/fixtures/mc')
+    end
+
+    it 'should handle edge cases, like KISS files with arbitrary next-states' do
+      lambda { FSM.from_kiss 'spec/fixtures/ex5' }.should_not raise_error
+    end
+
+    it 'should properly report the number of inputs' do
+      @opus.input_count.should == 5
+      @lion.input_count.should == 2
+      @mc.input_count.should   == 3
+    end
+
+    it 'should properly report the number of outputs' do
+      @opus.output_count.should == 6
+      @lion.output_count.should == 1
+      @mc.output_count.should   == 5
+    end
+
+    it 'should properly generate the Q Blanket' do
+      @opus.beta_q.should == Blanket[B[0,1,2], B[0,3,4], B[0,5], B[0,6,7], B[0,8,9,10,11,12,13,14], B[0,15,16], B[0,17,18], B[0,19], B[0,20], B[0,21]]
+      @lion.beta_q.should == Blanket[B[0,1,2], B[3,4,5], B[6,7,8], B[9,10]]
+      @mc.beta_q.should   == Blanket[B[0,1,2], B[3,4], B[5,6,7], B[8,9]]
+    end
+
+    it 'should properly generate the F Blanket' do
+      @opus.beta_f.should == Blanket[B[0,1], B[2,3,9], B[4,14], B[5,6], B[7,8,20,21], B[10,16], B[11,18], B[12,15], B[13,17], B[19]]
+      @lion.beta_f.should == Blanket[B[0,1,4], B[2], B[2,3,7], B[5,6,10], B[8,9]]
+      @mc.beta_f.should   == Blanket[B[0,1], B[2], B[3], B[4], B[5], B[6,7], B[8], B[9]]
+    end
+
+    it 'should properly generate selected inputs Blankets' do
+      @mc.beta_x(Set[0]).should   == Blanket[B[0,1,3,4,6,7,8,9], B[1,2,3,4,5,7,8,9]]
+      @mc.beta_x(Set[1,2]).should == Blanket[B[0,1,3,5,6,8], B[0,1,4,5,6,9], B[0,2,3,6,7,8], B[0,2,4,6,7,9]]
+      @mc.beta_x(Set[]).should    == Blanket[B[0,1,2,3,4,5,6,7,8,9]]
+    end
+
+    it 'should properly generate its KISS representation' do
+      @opus.to_kiss.should == File.read('spec/fixtures/opus.to_kiss')
+      @lion.to_kiss.should == File.read('spec/fixtures/lion.to_kiss')
+      @mc.to_kiss.should   == File.read('spec/fixtures/mc.to_kiss')
+    end
+
+    it 'should return given inputs’ encoding for the given row(s)' do
+      @opus.x_encoding(Set[2], B[0]).should   == '1'
+      @opus.x_encoding(Set[0], B[0]).should   == '-'
+      @opus.x_encoding(Set[0], B[7,8]).should == '0'
+      lambda { @opus.x_encoding Set[0], B[8,9] }.should raise_error(AmbiguousEncodingQuery, 'ambiguous encoding query: block 8,9')
+      @opus.x_encoding(Set[0,2], B[0]).should == '-1'
+    end
+
+    it 'should return output encoding for the given row(s)' do
+      @opus.y_encoding(B[0]).should       == '110000'
+      @opus.y_encoding(B[0,1,2,3]).should == '110000'
+      lambda { @opus.y_encoding B[3,4] }.should raise_error(AmbiguousEncodingQuery, 'ambiguous encoding query: block 3,4')
+      @lion.y_encoding(B[2,3]).should     == '1'
+      @mark1.y_encoding(B[0]).should      == '-11---1-00------'
+      @mark1.y_encoding(B[0,16]).should   == '-11---1-00100000'
+    end
+
+    it 'should return state encoding for the given row(s)' do
+      @opus.q_encoding(B[1]).should     == 'init0'
+      @opus.q_encoding(B[1,2]).should   == 'init0'
+      @opus.q_encoding(B[0,1,2]).should == 'init0'
+      @opus.q_encoding(B[0]).should     == '-'
+      lambda { @opus.q_encoding B[2,3] }.should raise_error(AmbiguousEncodingQuery, 'ambiguous encoding query: block 2,3')
+    end
+
+    it 'should return the row(s) of a state matching next-state of given row(s)' do
+      @opus.state_rows_of_next_state_of(B[20,21]).should == B[0,8,9,10,11,12,13,14]
+      @mark1.state_rows_of_next_state_of(B[2]).should    == B[0,22]
+    end
+
+    it 'should equal/not-equal other FSMs and hash properly' do
+      @lion.should_not  == FSM.from_kiss('spec/fixtures/opus')
+      @lion.should      == FSM.from_kiss('spec/fixtures/lion')
+      @lion.hash.should == FSM.from_kiss('spec/fixtures/lion').hash
+      @lion.should     eql FSM.from_kiss('spec/fixtures/lion')
+    end
+
+    it 'should expand selected input columns and return a new FSM instance' do
+      @lion.expand_x(Set[0,1]).should    == FSM.from_kiss('spec/fixtures/lion.exp')
+      @fsm.expand_x(Set[0,1,2,3]).should == FSM.from_kiss('spec/fixtures/fsm.exp')
+      @fsm.expand_x(Set[0,3]).should     == FSM.from_kiss('spec/fixtures/fsm.partially-exp')
+    end
+
+    it 'should return self if asked to expand columns lacking don’t-cares' do
+      opus = FSM.from_kiss 'spec/fixtures/opus.to_kiss'
+      opus.expand_x(Set[2]).should equal opus
+    end
+
+    it 'should report its input/output/state counts' do
+      @fsm.stats.should   == '4/2+10s'
+      @lion.stats.should  == '2/1+4s'
+      @mark1.stats.should == '5/16+15s'
+      @mc.stats.should    == '3/5+4s'
+      @opus.stats.should  == '5/6+10s'
+    end
+
+    it 'should report whether its directly implementable in a given Set of Archs' do
+      @lion.should   be_implementable_in Set[Arch[4,2]]
+      @mc.should_not be_implementable_in Set[Arch[4,2]]
+      @mc.should     be_implementable_in Set[Arch[5,1]]
+      @s8.should     be_implementable_in Set[Arch[2,1]]
+    end
+
+    it 'should report the cell count for a given Set of Archs (if it’s implementable in it)' do
+      @lion.fsm_cells(Set[Arch[4,1]]).should == 3
+      @lion.fsm_cells(Set[Arch[4,2]]).should == 2
+      @mc.fsm_cells(Set[Arch[4,2]]).should be_nil
+      @mc.fsm_cells(Set[Arch[5,1]]).should   == 7
+      @s8.fsm_cells(Set[Arch[2,1]]).should   == 0
+      @s8.fsm_cells(Set[Arch[3,2]]).should   == 0
+      @s8.fsm_cells(Set[Arch[4,1]]).should   == 0
+    end
+
+    it 'should report its input relevance, and drop irrelevant inputs' do
+      @fsm.input_relevance.should   == [2, 1, 3, 0, nil, nil, nil, nil]
+      @lion.input_relevance.should  == [0, nil, nil, 1]
+      @mark1.input_relevance.should == [nil, nil, nil, nil, 0, 3, 2, 4, 1]
+      @mc.input_relevance.should    == [nil, nil, 2, 1, 0]
+      @opus.input_relevance.should  == [nil, nil, nil, nil, 2, 3, 4, 0, 1]
+      @s8.input_relevance.should    == [3, 2, 1, 0, nil, nil, nil]
+      @s420.input_relevance.should  == [1, 0, 18, nil, nil, nil, nil, nil, 17, 16, 15, 14, 13]
+    end
+
+  end
+
+end end