y_petri 1.0.0

data/test/y_petri_test.rb

@@ -0,0 +1,1521 @@
+#! /usr/bin/ruby
+#encoding: utf-8
+
+require 'minitest/spec'
+require 'minitest/autorun'
+require_relative '../lib/y_petri'     # tested component itself
+# require 'y_petri'
+
+# require 'sy'
+
+include Pyper if require 'pyper'
+
+# **************************************************************************
+# Test of Place class, part I.
+# **************************************************************************
+#
+describe ::YPetri::Place do
+  before do
+    # skip "to speed up testing"
+    @pç = pç = Class.new ::YPetri::Place
+    @p = pç.new! default_marking: 3.2,
+                 marking: 1.1,
+                 quantum: 0.1,
+                 name: "P1"
+  end
+
+  describe "place behavior" do
+    before do
+      @p.m = 1.1
+    end
+
+    it "should have constant magic included" do
+      assert_respond_to @p, :name
+      assert_equal @p.name, :P1
+    end
+
+    it "should have own marking and be able to update it" do
+      assert_equal 1.1, @p.marking
+      assert_equal 0.1, @p.quantum
+      assert_equal :P1, @p.name
+      @p.add 1
+      assert_equal 2.1, @p.value        # alias for #marking
+      @p.subtract 0.5
+      assert_equal 1.6, @p.m
+      @p.reset_marking
+      assert_equal 3.2, @p.marking
+    end
+
+    it "should respond to the arc getters" do
+      # #action_arcs & aliases
+      assert_equal [], @p.upstream_arcs
+      assert_equal [], @p.upstream_transitions
+      assert_equal [], @p.ϝ
+      # #test_arcs & aliases
+      assert_equal [], @p.downstream_arcs
+      assert_equal [], @p.downstream_transitions
+      # #arcs & aliasesnn
+      assert_equal [], @p.arcs
+      assert_equal [], @p.connectivity
+      # #precedents & aliases
+      assert_equal [], @p.precedents
+      assert_equal [], @p.upstream_places
+      # #dependents & aliases
+      assert_equal [], @p.dependents
+      assert_equal [], @p.downstream_places
+    end
+
+    it "should respond to register and fire conn. transitions methods" do
+      assert_respond_to @p, :fire_upstream!
+      assert_respond_to @p, :fire_downstream!
+      assert_respond_to @p, :fire_upstream_recursively
+      assert_respond_to @p, :fire_downstream_recursively
+    end
+  end
+end
+
+# **************************************************************************
+# Test of Transition class, part I.
+# **************************************************************************
+#
+describe ::YPetri::Transition do
+  before do
+    # skip "to speed up testing"
+    @ç = ç = Class.new ::YPetri::Transition
+    @pç = pç = Class.new ::YPetri::Place
+    [ ç, pç ].each { |ç|
+      ç.class_exec {
+        define_method :Place do pç end
+        define_method :Transition do ç end
+        private :Place, :Transition
+      }
+    }
+    @p1 = pç.new default_marking: 1.0
+    @p2 = pç.new default_marking: 2.0
+    @p3 = pç.new default_marking: 3.0
+    @p4 = pç.new default_marking: 4.0
+    @p5 = pç.new default_marking: 5.0
+  end
+
+  describe "1. timeless nonstoichiometric (ts) transitions" do
+
+    # Note that timeless nonstoichiometric transitions require a function
+    # block, and thus are always functional
+
+    before do
+      @t1 = @ç.new codomain: [ @p1, @p3 ], domain: @p2, action: λ { |a| [ a, a ] }
+      # saying that the trans. is timed saves the day here:
+      @t2 = @ç.new codomain: [ @p1, @p3 ], action: λ { |t| [ t, t ] }, timed: true
+      # Only with domain is 1-ary closure allowed to be timeless:
+      @t3 = @ç.new codomain: [ @p1, @p3 ], action: λ { |t| [ t, t ] }, timed: false, domain: [ @p2 ]
+      # With nullary action closure, timeless is implied, so this is allowed
+      @t4 = @ç.new action: λ { [ 0.5, 0.5 ] }, codomain: [ @p1, @p3 ]
+      # ... also for stoichiometric variety
+      @t5 = @ç.new action: λ { 0.5 }, codomain: [ @p1, @p3 ], s: [ 1, 1 ]
+    end
+
+    it "should raise errors for bad parameters" do
+      # omitting the domain should raise ArgumentError about too much ambiguity:
+      assert_raises AErr do @ç.new codomain: [ @p1, @p3 ], action: λ { |t| [ t, t ] } end
+      # saying that the transition is timeless points to a conflict:
+      assert_raises AErr do @ç.new codomain: [ @p1, @p3 ], action: λ { |t| [ t, t ] }, timeless: true end
+    end
+
+    it "should initi and perform" do
+      assert_equal [ @p2 ], @t1.domain
+      assert_equal [ @p1, @p3 ], @t1.action_arcs
+      assert @t1.functional?
+      assert @t1.timeless?
+      assert @t2.timed?
+      assert [@t3, @t4, @t5].all? { |t| t.timeless? }
+      assert @t2.rateless?
+      # that's enough, now let's flex them:
+      @t1.fire!
+      assert_equal [3, 5], [ @p1.marking, @p3.marking ]
+      @t3.fire!
+      assert_equal [5, 7], [ @p1.marking, @p3.marking ]
+      @t4.fire!
+      assert_equal [5.5, 7.5], [ @p1.marking, @p3.marking ]
+      @t5.fire!
+      assert_equal [6, 8], [ @p1.marking, @p3.marking ]
+      # now t2 for firing requires delta time
+      @t2.fire! 1
+      assert_equal [7, 9], [ @p1.marking, @p3.marking ]
+      @t2.fire! 0.1
+      assert_equal [7.1, 9.1], [@p1.marking, @p3.marking ]
+      # let's change @p2 marking
+      @p2.marking = 0.1
+      @t1.fire!
+      assert_in_epsilon 7.2, @p1.marking, 1e-9
+      assert_in_epsilon 9.2, @p3.marking, 1e-9
+      # let's test #domain_marking, #codomain_marking, #zero_action
+      assert_equal [ @p1.marking, @p3.marking ], @t1.codomain_marking
+      assert_equal [ @p2.marking ], @t1.domain_marking
+      assert_equal [ 0, 0 ], @t1.zero_action
+    end
+  end
+
+  describe "2. timed rateless non-stoichiometric (Tsr) transitions" do
+    #LATER: To save time, I omit the full test suite.
+  end
+
+  describe "3. timeless stoichiometric (tS) transitions" do
+    describe "functionless tS transitions" do
+
+      # For transitions with no function given (ie. functionless), it is
+      # required that their stoichiometric vector be given and their action
+      # closure is then automatically generated from the stoichio. vector
+
+      before do
+        # timeless transition with stoichiometric vector only, as hash
+        @ftS1 = @ç.new stoichiometry: { @p1 => 1 }
+        # timeless transition with stoichiometric vector as array + codomain
+        @ftS2 = @ç.new stoichiometry: 1, codomain: @p1
+        # :stoichiometric_vector is aliased as :sv
+        @ftS3 = @ç.new s: 1, codomain: @p1
+        # :codomain is aliased as :action_arcs
+        @ftS4 = @ç.new s: 1, action_arcs: @p1
+        # dropping of square brackets around size 1 vectors is optional
+        @ftS5 = @ç.new s: [ 1 ], downstream: [ @p1 ]
+        # another alias for :codomain is :downstream_places
+        @ftS6 = @ç.new s: [ 1 ], downstream_places: [ @p1 ]
+        # and now, all of the above transitions...
+        @tt = @ftS1, @ftS2, @ftS3, @ftS4, @ftS5, @ftS6
+      end
+
+      it "should work" do
+        # ...should be the same, having a single action arc:
+        assert @tt.all?{ |t| t.action_arcs == [ @p1 ] }
+        # timeless:
+        assert @tt.all?{ |t| t.timeless? }
+        # rateless:
+        assert @tt.all?{ |t| t.rateless? }
+        assert @tt.all?{ |t| not t.has_rate? }
+        # no assignment action
+        assert @tt.all?{ |t| not t.assignment_action? }
+        # not considered functional
+        assert @tt.all?{ |t| t.functionless? }
+        assert @tt.all?{ |t| not t.functional? }
+        # and having nullary action closure
+        assert @tt.all?{ |t| t.action_closure.arity == 0 }
+        # the transitions should be able to #fire!
+        @ftS1.fire!
+        # the difference is apparent: marking of place @p1 jumped to 2:
+        assert_equal 2, @p1.marking
+        # but should not #fire (no exclamation mark) unless cocked
+        assert !@ftS1.cocked?
+        @ftS1.fire
+        assert_equal 2, @p1.marking
+        # cock it
+        @ftS1.cock
+        assert @ftS1.cocked?
+        # uncock again, just to test cocking
+        @ftS1.uncock
+        assert @ftS1.uncocked?
+        @ftS1.cock
+        assert !@ftS1.uncocked?
+        @ftS1.fire
+        assert_equal 3, @p1.marking
+        # enough playing, we'll reset @p1 marking
+        @p1.reset_marking
+        assert_equal 1, @p1.marking
+        # #action
+        assert @tt.all?{ |t| t.action == [ 1 ] }
+        # #zero_action
+        assert @tt.all?{ |t| t.zero_action }
+        # #action_after_feasibility_check
+        assert @tt.all?{ |t| t.action_after_feasibility_check == [ 1 ] }
+        # #domain_marking
+        assert @tt.all?{ |t| t.domain_marking == [] }
+        # #codomain_marking
+        assert @tt.all?{ |t| t.codomain_marking == [ @p1.marking ] }
+        # #enabled?
+        assert @tt.all?{ |t| t.enabled? == true }
+      end
+    end
+
+    describe "functional tS transitions" do
+
+      # If function block is supplied to tS transitions, it governs
+      # their action based on marking of the domain places.
+
+      before do
+        # stoichiometric vector given as hash
+        @FtS1 = @ç.new action_closure: λ { 1 }, s: { @p1 => 1 }
+        # instead of :action_closure, just saying :action is enough
+        @FtS2 = @ç.new action: λ { 1 }, s: { @p1 => 1 }
+        # stoichiometric vector given as coeff. array + codomain
+        @FtS3 = @ç.new s: 1, codomain: @p1, action: λ { 1 }
+        # while saying timed: false and timeless: true should be ok
+        @FtS4 = @ç.new s: { @p1 => 1 }, action: λ { 1 }, timed: false
+        @FtS5 = @ç.new s: { @p1 => 1 }, action: λ { 1 }, timeless: true
+        # even both are ok
+        @FtS6 = @ç.new s: { @p1 => 1 }, action: λ { 1 }, timed: false, timeless: true
+        @tt = @FtS1, @FtS2, @FtS3, @FtS4, @FtS5, @FtS6
+      end
+
+      it "should raise errors for bad parameters" do
+        # saying timed: true should raise a complaint:
+        assert_raises AErr do @ç.new sv: { @p1 => 1 }, action: λ{ 1 }, timed: true end
+        # same for saying timeless: false
+        assert_raises AErr do
+          @ç.new sv: { @p1 => 1 }, action: λ{ 1 }, timeless: false end
+        # while conflicting values will raise error
+        assert_raises AErr do
+          @ç.new sv: { @p1 => 1 }, action: λ { 1 }, timeless: true, timed: true
+        end
+      end
+
+      it "should init and perform" do
+        assert @tt.all?{ |t| t.action_arcs == [ @p1 ] }
+        assert @tt.all?{ |t| t.timeless? }
+        assert @tt.all?{ |t| not t.has_rate? }
+        assert @tt.all?{ |t| t.rateless? }
+        assert @tt.all?{ |t| not t.assignment_action? }
+        assert @tt.all?{ |t| not t.functionless? }
+        assert @tt.all?{ |t| t.functional? }
+        # and having nullary action closure
+        assert @tt.all?{ |t| t.action_closure.arity == 0 }
+        # the transitions should be able to #fire!
+        @FtS1.fire!
+        # no need for more testing here
+      end
+    end
+  end
+
+  describe "4. timed rateless stoichiometric (TSr) transitions" do
+
+    # Rateless stoichiometric transitions have action closure, and they
+    # require a function block, and thus are always functional. Their
+    # function block must take Δt as its first argument.
+
+    #LATER: To save time, I omit the tests of TSr transitions for now.
+  end
+
+  describe "5. nonstoichiometric transitions with rate (sR transitions)" do
+    
+    # They require a function block with arity equal to their domain, whose
+    # output is an array of rates of the size equal to that of codomain.
+
+    #LATER: To save time, I omit the full test suite.
+  end
+
+  describe "6. stoichiometric transitions with rate (SR transitions)" do
+    before do
+      # now this should give standard mass action by magic:
+      @SR1 = @ç.new s: { @p1 => -1, @p2 => -1, @p4 => 1 }, flux_closure: 0.1
+      # while this has custom flux closure
+      @SR2 = @ç.new s: { @p1 => -1, @p3 => 1 }, flux_closure: λ { |a| a * 0.5 }
+      # while this one even has domain specified:
+      @SR3 = @ç.new s: { @p1 => -1, @p2 => -1, @p4 => 1 }, upstream_arcs: @p3, flux: λ { |a| a * 0.5 }
+    end
+
+    it "should init and work" do
+      assert_equal true, @SR1.has_rate?
+      assert_equal [ @p1, @p2 ], @SR1.upstream_arcs
+      assert_equal [ @p1, @p2, @p4 ], @SR1.action_arcs
+      assert_equal [ @p1 ], @SR2.domain
+      assert_equal [ @p1, @p3 ], @SR2.action_arcs
+      assert_equal [ @p3 ], @SR3.domain
+      assert_equal [ @p1, @p2, @p4 ], @SR3.action_arcs
+      # and flex them
+      @SR1.fire! 1.0
+      assert_equal [ 0.8, 1.8, 4.2 ], [ @p1, @p2, @p4 ].map( &:marking )
+      @SR2.fire! 1.0
+      assert_equal [ 0.4, 3.4 ], [ @p1, @p3 ].map( &:marking )
+      # the action t3 cannot fire with delta time 1.0
+      assert_raises RuntimeError do @SR3.fire! 1.0 end
+      assert_equal [ 0.4, 1.8, 3.4, 4.2 ], [ @p1, @p2, @p3, @p4 ].map( &:marking )
+      # but it can fire with eg. delta time 0.1
+      @SR3.fire! 0.1
+      assert_in_epsilon 0.23, @p1.marking, 1e-15
+      assert_in_epsilon 1.63, @p2.marking, 1e-15
+      assert_in_epsilon 3.4, @p3.marking, 1e-15
+      assert_in_epsilon 4.37, @p4.marking, 1e-15
+    end
+  end
+end
+
+
+# **************************************************************************
+# Test of mutual knowedge of upstream/downstream arcs of places/transitions.
+# **************************************************************************
+#
+describe "upstream and downstream reference mτs of places and transitions" do
+  before do
+    # skip "to speed up testing"
+    @tç = tç = Class.new ::YPetri::Transition
+    @pç = pç = Class.new ::YPetri::Place
+    [ tç, pç ].each { |ç|
+      ç.class_exec {
+        define_method :Place do pç end
+        define_method :Transition do tç end
+        private :Place, :Transition
+      }
+    }
+    @a = @pç.new( dflt_m: 1.0 )
+    @b = @pç.new( dflt_m: 2.0 )
+    @c = @pç.new( dflt_m: 3.0 )
+  end
+
+  describe "Place" do
+    it "should have #register_ustream/downstream_transition methods" do
+      @t1 = @tç.new s: {}
+      @a.instance_variable_get( :@upstream_arcs ).must_equal []
+      @a.instance_variable_get( :@downstream_arcs ).must_equal []
+      @a.send :register_upstream_transition, @t1
+      @a.instance_variable_get( :@upstream_arcs ).must_equal [ @t1 ]
+    end
+  end
+
+  describe "upstream and downstream reference methods" do
+    before do
+      @t1 = @tç.new s: { @a => -1, @b => 1 }, rate: 1
+    end
+
+    it "should show on the referencers" do
+      @a.upstream_arcs.must_equal [ @t1 ]
+      @b.downstream_arcs.must_equal [ ]
+      @b.ϝ.must_equal [ @t1 ]
+      @t1.upstream_arcs.must_equal [ @a ]
+      @t1.action_arcs.must_equal [ @a, @b ]
+    end
+  end
+
+  describe "assignment action transitions" do
+    before do
+      @p = @pç.new default_marking: 1.0
+      @t = @tç.new codomain: @p, action: λ { 1 }, assignment_action: true
+    end
+
+    it "should work" do
+      @p.marking = 3
+      assert_equal 3, @p.marking
+      assert @t.assignment_action?
+      assert_equal @t.domain, []
+      assert_equal 0, @t.action_closure.arity
+      @t.fire!
+      assert_equal 1, @p.marking
+    end
+  end # context assignment action transiotions
+end
+
+
+# **************************************************************************
+# Test of Net class.
+# **************************************************************************
+#
+describe ::YPetri::Net do
+  before do
+    # skip "to speed up testing"
+    @tç = tç = Class.new ::YPetri::Transition
+    @pç = pç = Class.new ::YPetri::Place
+    @nç = nç = Class.new ::YPetri::Net
+    [ tç, pç, nç ].each { |ç|
+      ç.class_exec {
+        define_method :Place do pç end
+        define_method :Transition do tç end
+        define_method :Net do nç end
+        private :Place, :Transition, :Net
+      }
+    }
+    @p1 = pç.new ɴ: "A", quantum: 0.1, marking: 1.1
+    @p2 = pç.new ɴ: "B", quantum: 0.1, marking: 2.2
+    @p3 = pç.new ɴ: "C", quantum: 0.1, marking: 3.3
+    @net = nç.new
+    [ @p1, @p2, @p3 ].each { |p| @net.include_place! p }
+    @p_not_included = pç.new ɴ: "X", m: 0
+  end
+
+  describe "net of 3 places and no transitions" do
+    before do
+      @p1.m = 1.1
+      @p2.m = 2.2
+      @p3.m = 3.3
+    end
+
+    it "should expose its elements" do
+      assert_equal [@p1, @p2, @p3], @net.places
+      assert_equal [:A, :B, :C], @net.pp
+      assert_equal [], @net.transitions
+    end
+
+    it "should expose transition groups" do
+      assert_equal [], @net.transitions_with_rate
+      assert_equal [], @net.rateless_transitions
+      assert_equal [], @net.transitions_without_rate
+      assert_equal [], @net.stoichiometric_transitions
+      assert_equal [], @net.nonstoichiometric_transitions
+    end
+
+    it "should tell its qualities" do
+      assert_equal true, @net.functional?
+      assert_equal true, @net.timed?
+      assert @net.include?( @p1 ) && !@net.include?( nil )
+    end
+
+    it "should have 'standard equipment' methods" do
+      assert @net == @net.dup
+      assert @net.inspect.start_with? "#<Net:"
+      assert @net.include?( @p1 )
+      assert ! @net.include?( @p_not_included )
+      begin
+        @net.exclude_place! @p_not_included
+        @net.include_transition! YPetri::Transition.new( s: { @p_not_included => -1 } )
+        flunk "Attempt to include illegal transition fails to raise"
+      rescue; end
+    end
+
+    describe "plus 1 stoichio. transition with rate" do
+      before do
+        @t1 = @tç.new!( ɴ: "T1",
+                        s: { @p1 => 1, @p2 => -1, @p3 => -1 },
+                        rate: 0.01 )
+        @net.include_transition! @t1
+      end
+
+      it "should expose its elements" do
+        assert_equal [@t1], @net.transitions
+        assert_equal [:T1], @net.tt
+      end
+
+      it "should expose transition groups" do
+        assert_equal true, @t1.has_rate?
+        assert_equal [@t1], @net.transitions_with_rate
+        assert_equal [], @net.rateless_transitions
+        assert_equal [@t1], @net.stoichiometric_transitions
+        assert_equal [], @net.nonstoichiometric_transitions
+      end
+
+      it "should tell its qualities" do
+        assert_equal true, @net.functional?
+        assert_equal true, @net.timed?
+        assert @net.include?( @t1 )
+      end
+
+      it "should have #place & #transition for safe access to the said elements" do
+        @net.send( :place, @p1 ).must_equal @p1
+        @net.send( :transition, @t1 ).must_equal @t1
+      end
+
+      it "has #new_simulation & #new_timed_simulation constructors" do
+        @net.must_respond_to :new_simulation
+        @net.must_respond_to :new_timed_simulation
+      end
+
+      it "should have other methods" do
+        assert_equal [1.1, 2.2, 3.3], [@p1, @p2, @p3].map( &:marking ).map{ |n| n.round 6 }
+        assert_equal 2.2 * 3.3 * 0.01, @t1.rate_closure.call( @p2.marking, @p3.marking )
+        assert_equal [ @p2, @p3 ], @t1.domain
+        @t1.fire! 1
+        assert_equal [1.1726, 2.1274, 3.2274], [@p1, @p2, @p3].map( &:marking ).map{ |n| n.round 6 }
+      end
+
+      describe "plus 1 more nameless timeless functionless transition" do
+        before do
+          @t2 = @tç.new s: { @p2 => -1, @p3 => 1 }
+          @net.include_transition! @t2
+        end
+
+        it "should expose its elements" do
+          assert_equal [@t1, @t2], @net.transitions
+          assert_equal [:T1, nil], @net.tt
+          @net.tap{ |n| n.exclude_transition! @t1 }.exclude_transition! @t2
+          @net.tap{ |n| n.exclude_place! @p3 }.pp.must_equal [:A, :B]
+        end
+
+        it "should expose transition groups" do
+          assert_equal [], @net.timeless_nonstoichiometric_transitions
+          assert_equal [], @net.timeless_nonstoichiometric_tt
+          assert_equal [@t2], @net.timeless_stoichiometric_transitions
+          assert_equal [nil], @net.timeless_stoichiometric_tt
+          assert_equal [], @net.timed_nonstoichiometric_transitions_without_rate
+          assert_equal [], @net.timed_rateless_nonstoichiometric_transitions
+          assert_equal [], @net.timed_nonstoichiometric_tt_without_rate
+          assert_equal [], @net.timed_rateless_nonstoichiometric_tt
+          assert_equal [], @net.timed_nonstoichiometric_transitions_without_rate
+          assert_equal [], @net.timed_rateless_nonstoichiometric_transitions
+          assert_equal [], @net.timed_nonstoichiometric_tt_without_rate
+          assert_equal [], @net.timed_rateless_nonstoichiometric_tt
+          assert_equal [], @net.nonstoichiometric_transitions_with_rate
+          assert_equal [], @net.nonstoichiometric_tt_with_rate
+          assert_equal [@t1], @net.stoichiometric_transitions_with_rate
+          assert_equal [:T1], @net.stoichiometric_tt_with_rate
+          assert_equal [], @net.transitions_with_explicit_assignment_action
+          assert_equal [], @net.transitions_with_assignment_action
+          assert_equal [], @net.assignment_transitions
+          assert_equal [], @net.tt_with_explicit_assignment_action
+          assert_equal [], @net.tt_with_assignment_action
+          assert_equal [], @net.assignment_tt
+          assert_equal [@t1, @t2], @net.stoichiometric_transitions
+          assert_equal [:T1, nil], @net.stoichiometric_tt
+          assert_equal [], @net.nonstoichiometric_transitions
+          assert_equal [], @net.nonstoichiometric_tt
+          assert_equal [@t1], @net.timed_transitions
+          assert_equal [:T1], @net.timed_tt
+          assert_equal [@t2], @net.timeless_transitions
+          assert_equal [nil], @net.timeless_tt
+          assert_equal [@t1], @net.transitions_with_rate
+          assert_equal [:T1], @net.tt_with_rate
+          assert_equal [@t2], @net.rateless_transitions
+          assert_equal [nil], @net.rateless_tt
+        end
+
+        it "should tell its qualities" do
+          assert_equal false, @net.functional?
+          assert_equal false, @net.timed?
+          @net.exclude_transition! @t2
+          assert_equal true, @net.functional?
+          assert_equal true, @net.timed?
+        end
+      end
+    end
+  end
+end
+
+
+# **************************************************************************
+# Test of Simulation class.
+# **************************************************************************
+#
+describe ::YPetri::Simulation do
+  before do
+    # skip "to make the testing faster"
+    @pç = pç = Class.new( ::YPetri::Place )
+    @tç = tç = Class.new( ::YPetri::Transition )
+    @nç = nç = Class.new( ::YPetri::Net )
+    [ @pç, @tç, @nç ].each { |klass|
+      klass.class_exec {
+        private
+        define_method :Place do pç end
+        define_method :Transition do tç end
+        define_method :Net do nç end
+      }
+    }
+    @p1 = @pç.new name: "P1", default_marking: 1
+    @p2 = @pç.new name: "P2", default_marking: 2
+    @p3 = @pç.new name: "P3", default_marking: 3
+    @p4 = @pç.new name: "P4", default_marking: 4
+    @p5 = @pç.new name: "P5", default_marking: 5
+    @t1 = @tç.new name: "T1",
+                  s: { @p1 => -1, @p2 => -1, @p4 => 1 },
+                  flux_closure: 0.1
+    @t2 = @tç.new name: "T2",
+                  s: { @p1 => -1, @p3 => 1 },
+                  flux_closure: λ { |a| a * 0.5 }
+    @t3 = @tç.new name: "T3",
+                  s: { @p1 => -1, @p2 => -1, @p4 => 1 },
+                  domain: @p3, flux: λ { |a| a * 0.5 }
+    @net = @nç.new << @p1 << @p2 << @p3 << @p4 << @p5
+    @net.include_transition! @t1
+    @net.include_transition! @t2
+    @net << @t3
+    @s = YPetri::Simulation.new net: @net,
+                                place_clamps: { @p1 => 2.0, @p5 => 2.0 },
+                                initial_marking: { @p2 => @p2.default_marking,
+                                                   @p3 => @p3.default_marking,
+                                                   @p4 => @p4.default_marking }
+  end
+
+  it "exposes the net" do
+    @s.net.must_equal @net
+    @s.net.places.size.must_equal 5
+    @s.net.transitions.size.must_equal 3
+    assert @net.include? @t1
+    assert @s.net.include? @t1
+    assert @net.include? @t2
+    assert @s.net.include? @t2
+    assert @net.include? @t3
+    assert @s.net.include? @t3
+    @s.net.transitions.size.must_equal 3
+  end
+
+  it "exposes Petri net places" do
+    @s.places.must_equal [ @p1, @p2, @p3, @p4, @p5 ]
+    @s.pp.must_equal [ :P1, :P2, :P3, :P4, :P5 ]
+    @s.places( :pp ).must_equal( { @p1 => :P1, @p2 => :P2, @p3 => :P3,
+                                   @p4 => :P4, @p5 => :P5 } )
+    @s.pp( :pp ).must_equal( { P1: :P1, P2: :P2, P3: :P3, P4: :P4, P5: :P5 } )
+  end
+
+  it "exposes Petri net transitions" do
+    @s.transitions.must_equal [ @t1, @t2, @t3 ]
+    @s.tt.must_equal [ :T1, :T2, :T3 ]
+    @s.transitions( :tt ).must_equal( { @t1 => :T1, @t2 => :T2, @t3 => :T3 } )
+    @s.tt( :tt ).must_equal( { T1: :T1, T2: :T2, T3: :T3 } )
+  end
+
+  it "exposes place clamps" do
+    @s.clamped_places( :place_clamps ).must_equal( { @p1 => 2, @p5 => 2 } )
+    @s.clamped_pp( :place_clamps ).must_equal( { P1: 2, P5: 2 } )
+  end
+
+  it "presents free places" do
+    @s.free_places.must_equal [ @p2, @p3, @p4 ]
+    @s.free_pp.must_equal [ :P2, :P3, :P4 ]
+    @s.free_places( :free_pp )
+      .must_equal( { @p2 => :P2, @p3 => :P3, @p4 => :P4 } )
+    @s.free_pp( :free_pp )
+      .must_equal( { P2: :P2, P3: :P3, P4: :P4 } )
+  end
+
+  it "presents clamped places" do
+    @s.clamped_places.must_equal [ @p1, @p5 ]
+    @s.clamped_pp.must_equal [ :P1, :P5 ]
+    @s.clamped_places( :clamped_pp ).must_equal( { @p1 => :P1, @p5 => :P5 } )
+    @s.clamped_pp( :clamped_pp ).must_equal( { P1: :P1, P5: :P5 } )
+  end
+
+  it "exposes initial marking" do
+    @s.free_places( :im ).must_equal( { @p2 => 2, @p3 => 3, @p4 => 4 } )
+    @s.free_pp( :im ).must_equal( { P2: 2, P3: 3, P4: 4 } )
+    @s.im.must_equal [ 2, 3, 4 ]
+    @s.im_vector.must_equal Matrix[[2], [3], [4]]
+    @s.im_vector.must_equal @s.iᴍ
+  end
+
+  it "exposes marking (simulation state)" do
+    @s.m.must_equal [2, 3, 4] # (we're after reset)
+    @s.free_places( :m ).must_equal( { @p2 => 2, @p3 => 3, @p4 => 4 } )
+    @s.free_pp( :m ).must_equal( { P2: 2, P3: 3, P4: 4 } )
+    @s.ᴍ.must_equal Matrix[[2], [3], [4]]
+  end
+
+  it "separately exposes marking of clamped places" do
+    @s.m_clamped.must_equal [ 2, 2 ]
+    @s.clamped_places( :m_clamped ).must_equal( { @p1 => 2, @p5 => 2 } )
+    @s.clamped_pp( :m_clamped ).must_equal( { P1: 2, P5: 2 } )
+    @s.ᴍ_clamped.must_equal Matrix[[2], [2]]
+  end
+
+  it "exposes marking of all places (with capitalized M)" do
+    @s.marking.must_equal [ 2, 2, 3, 4, 2 ]
+    @s.places( :marking )
+      .must_equal( { @p1 => 2, @p2 => 2, @p3 => 3, @p4 => 4, @p5 => 2 } )
+    @s.pp( :marking ).must_equal( { P1: 2, P2: 2, P3: 3, P4: 4, P5: 2 } )
+    @s.marking_vector.must_equal Matrix[[2], [2], [3], [4], [2]]
+  end
+
+  it "has #S_for / #stoichiometry_matrix_for" do
+    assert_equal Matrix.empty(3, 0), @s.S_for( [] )
+    assert_equal Matrix[[-1], [0], [1]], @s.S_for( [@t1] )
+    x = Matrix[[-1, -1], [0, 0], [1, 1]]
+    x.must_equal @s.S_for( [@t1, @t3] )
+    x.must_equal( @s.S_for( [@t1, @t3] ) )
+    @s.stoichiometry_matrix_for( [] ).must_equal Matrix.empty( 5, 0 )
+  end
+
+  it "has stoichiometry matrix for 3. tS transitions" do
+    @s.S_for_tS.must_equal Matrix.empty( 3, 0 )
+  end
+
+  it "has stoichiometry matrix for 4. Sr transitions" do
+    @s.S_for_TSr.must_equal Matrix.empty( 3, 0 )
+  end
+
+  it "has stoichiometry matrix for 6. SR transitions" do
+    @s.S_for_SR.must_equal Matrix[[-1,  0, -1], [0, 1, 0], [1, 0, 1]]
+    @s.S.must_equal @s.S_for_SR
+  end
+
+  it "presents 1. ts" do
+    assert_equal [], @s.ts_transitions
+    assert_equal( {}, @s.ts_transitions( :ts_transitions ) )
+    assert_equal [], @s.ts_tt
+    assert_equal( {}, @s.ts_tt( :ts_tt ) )
+  end
+
+  it "presents 2. tS transitions" do
+    assert_equal [], @s.tS_transitions
+    assert_equal( {}, @s.tS_transitions( :tS_transitions ) )
+    assert_equal [], @s.tS_tt
+    assert_equal( {}, @s.tS_tt( :tS_tt ) )
+  end
+
+  it "presents 3. Tsr transitions" do
+    assert_equal [], @s.Tsr_transitions
+    assert_equal( {}, @s.Tsr_transitions( :Tsr_transitions ) )
+    assert_equal [], @s.Tsr_tt
+    assert_equal( {}, @s.Tsr_tt( :Tsr_tt ) )
+  end
+
+  it "presents 4. TSr transitions" do
+    assert_equal [], @s.TSr_transitions
+    assert_equal( {}, @s.TSr_transitions( :TSr_tt ) )
+    assert_equal [], @s.TSr_tt
+    assert_equal( {}, @s.TSr_tt( :TSr_tt ) )
+  end
+
+  it "presents 5. sR transitions" do
+    assert_equal [], @s.sR_transitions
+    assert_equal( {}, @s.sR_transitions( :sR_transitions ) )
+    assert_equal [], @s.sR_tt
+    assert_equal( {}, @s.sR_tt( :sR_tt ) )
+  end
+
+  it "presents SR transitions" do
+    assert_equal [@t1, @t2, @t3], @s.SR_transitions
+    assert_equal( { @t1 => :T1, @t2 => :T2, @t3 => :T3 },
+                  @s.SR_transitions( :SR_tt ) )
+    assert_equal [:T1, :T2, :T3], @s.SR_tt
+    assert_equal( { T1: :T1, T2: :T2, T3: :T3 }, @s.SR_tt( :SR_tt ) )
+  end
+
+  it "presents A transitions" do
+    assert_equal [], @s.A_transitions
+    assert_equal( {}, @s.A_transitions( :A_tt ) )
+    assert_equal [], @s.A_tt
+    assert_equal( {}, @s.A_tt( :A_tt ) )
+  end
+
+  it "presents S transitions" do
+    assert_equal [@t1, @t2, @t3], @s.S_transitions
+    assert_equal [:T1, :T2, :T3], @s.S_tt
+    assert_equal( { T1: :T1, T2: :T2, T3: :T3 }, @s.S_tt( :S_tt ) )
+  end
+
+  it "presents s transitions" do
+    assert_equal [], @s.s_transitions
+    assert_equal [], @s.s_tt
+    assert_equal( {}, @s.s_tt( :s_tt ) )
+  end
+
+  it "presents R transitions" do
+    assert_equal [@t1, @t2, @t3], @s.R_transitions
+    assert_equal [:T1, :T2, :T3], @s.R_tt
+    assert_equal( { T1: :T1, T2: :T2, T3: :T3 }, @s.R_tt( :R_tt ) )
+  end
+
+  it "presents r transitions" do
+    assert_equal [], @s.r_transitions
+    assert_equal [], @s.r_tt
+  end
+
+  it "1. handles ts transitions" do
+    @s.Δ_closures_for_ts.must_equal []
+    @s.Δ_if_ts_fire_once.must_equal Matrix.zero( @s.free_pp.size, 1 )
+  end
+
+  it "2. handles Tsr transitions" do
+    @s.Δ_closures_for_Tsr.must_equal []
+    @s.Δ_for_Tsr( 1.0 ).must_equal Matrix.zero( @s.free_pp.size, 1 )
+  end
+
+  it "3. handles tS transitions" do
+    @s.action_closures_for_tS.must_equal []
+    @s.action_vector_for_tS.must_equal Matrix.column_vector( [] )
+    @s.α_for_t.must_equal Matrix.column_vector( [] )
+    @s.Δ_if_tS_fire_once.must_equal Matrix.zero( @s.free_pp.size, 1 )
+  end
+
+  it "4. handles TSr transitions" do
+    @s.action_closures_for_TSr.must_equal []
+    @s.action_closures_for_Tr.must_equal []
+    @s.action_vector_for_TSr( 1.0 ).must_equal Matrix.column_vector( [] )
+    @s.action_vector_for_Tr( 1.0 ).must_equal Matrix.column_vector( [] )
+    @s.Δ_for_TSr( 1.0 ).must_equal Matrix.zero( @s.free_pp.size, 1 )
+  end
+
+  it "5. handles sR transitions" do
+    assert_equal [], @s.rate_closures_for_sR
+    assert_equal [], @s.rate_closures_for_s
+    @s.gradient_for_sR.must_equal Matrix.zero( @s.free_pp.size, 1 )
+    @s.Δ_Euler_for_sR( 1.0 ).must_equal Matrix.zero( @s.free_pp.size, 1 )
+  end
+
+  it "6. handles stoichiometric transitions with rate" do
+    @s.rate_closures_for_SR.size.must_equal 3
+    @s.rate_closures_for_S.size.must_equal 3
+    @s.rate_closures.size.must_equal 3
+    @s.flux_vector_for_SR.must_equal Matrix.column_vector( [ 0.4, 1.0, 1.5 ] )
+    @s.φ_for_SR.must_equal @s.flux_vector
+    @s.SR_tt( :φ_for_SR ).must_equal( { T1: 0.4, T2: 1.0, T3: 1.5 } )
+    @s.Euler_action_vector_for_SR( 1 )
+      .must_equal Matrix.column_vector [ 0.4, 1.0, 1.5 ]
+    @s.SR_tt( :Euler_action_for_SR, 1 ).must_equal( T1: 0.4, T2: 1.0, T3: 1.5 )
+    @s.Δ_Euler_for_SR( 1 ).must_equal Matrix[[-1.9], [1.0], [1.9]]
+    @s.free_pp( :Δ_Euler_for_SR, 1 ).must_equal( { P2: -1.9, P3: 1.0, P4: 1.9 } )
+  end
+
+  it "presents sparse stoichiometry vectors for its transitions" do
+    @s.sparse_σ( @t1 ).must_equal Matrix.cv( [-1, 0, 1] )
+    @s.sparse_stoichiometry_vector( @t1 )
+      .must_equal Matrix.cv( [-1, -1, 0, 1, 0] )
+  end
+
+  it "presents correspondence matrices free, clamped => all places" do
+    @s.F2A.must_equal Matrix[[0, 0, 0], [1, 0, 0], [0, 1, 0],
+                                    [0, 0, 1], [0, 0, 0]]
+    @s.C2A.must_equal Matrix[[1, 0], [0, 0], [0, 0], [0, 0], [0, 1]]
+  end
+end
+
+
+# **************************************************************************
+# Test of TimedSimulation class.
+# **************************************************************************
+#
+describe ::YPetri::TimedSimulation do  
+  before do
+    # skip "to speed up testing"
+    @a = ::YPetri::Place.new default_marking: 1.0
+    @b = ::YPetri::Place.new default_marking: 2.0
+    @c = ::YPetri::Place.new default_marking: 3.0
+  end
+
+  describe "timed assembly a + b >> c" do
+    before do
+      @t1 = ::YPetri::Transition.new s: { @a => -1, @b => -1, @c => 1 }, rate: 0.1
+      @net = ::YPetri::Net.new << @a << @b << @c << @t1
+      @im_collection = [@a, @b, @c].τBmχHτ &:default_marking
+    end
+
+    describe "simulation with step size 1" do
+      before do
+        @sim = ::YPetri::TimedSimulation.new net: @net,
+                                             initial_marking: @im_collection,
+                                             step: 1,
+                                             sampling: 10,
+                                             target_time: 100
+      end
+
+      it "should #step! with expected results" do
+        m = @sim.step!.marking
+        assert_in_delta 0.8, m[ 0 ], 1e-9
+        assert_in_delta 1.8, m[ 1 ], 1e-9
+        assert_in_delta 3.2, m[ 2 ], 1e-9
+      end
+
+      it "should behave" do
+        assert_in_delta 0, ( Matrix.column_vector( [-0.02, -0.02, 0.02] ) -
+                             @sim.ΔE( 0.1 ) ).column( 0 ).norm, 1e-9
+        @sim.step! 0.1
+        assert_in_delta 0, ( Matrix.column_vector( [0.98, 1.98, 3.02] ) -
+                             @sim.marking_vector ).column( 0 ).norm, 1e-9
+
+      end
+    end
+
+    describe "simulation with step size 0.1" do
+      before do
+        @sim = ::YPetri::TimedSimulation.new net: @net,
+                                             initial_marking: @im_collection,
+                                             step: 0.1,
+                                             sampling: 10,
+                                             target_time: 100
+      end
+
+      it "should behave" do
+        m = @sim.step!.marking
+        assert_equal 10, @sim.sampling_period
+        assert_in_delta 0.98, m[ 0 ], 1e-9
+        assert_in_delta 1.98, m[ 1 ], 1e-9
+        assert_in_delta 3.02, m[ 2 ], 1e-9
+      end
+
+      it "should behave" do
+        @sim.run_until_target_time! 31
+        expected_recording = {
+          0 => [ 1, 2, 3 ],
+          10 => [ 0.22265, 1.22265, 3.77735 ],
+          20 => [ 0.07131, 1.07131, 3.92869 ],
+          30 => [ 0.02496, 1.02496, 3.97503 ]
+        }
+        assert_equal expected_recording.keys, @sim.recording.keys
+        assert_in_delta 0, expected_recording.values.zip( @sim.recording.values )
+          .map{ |expected, actual| ( Vector[ *expected ] -
+                                     Vector[ *actual ] ).norm }.reduce( :+ ), 1e-4
+        expected_recording_string =
+          "0.0,1.0,2.0,3.0\n" +
+          "10.0,0.22265,1.22265,3.77735\n" +
+          "20.0,0.07131,1.07131,3.92869\n" +
+          "30.0,0.02496,1.02496,3.97504\n"
+        assert_equal expected_recording_string, @sim.recording_csv_string
+      end
+    end
+  end
+
+  describe "timed 'isomerization' with flux given as λ" do
+    before do
+      @t2 = ::YPetri::Transition.new s: { @a => -1, @c => 1 },
+                                     rate_closure: λ { |a| a * 0.5 }
+      @net = ::YPetri::Net.new << @a << @b << @c << @t2
+    end
+
+    describe "behavior of #step" do
+      before do
+        @sim = ::YPetri::TimedSimulation.new net: @net,
+                 initial_marking: [ @a, @b, @c ].τBᴍHτ( &:default_marking ),
+                 step: 1,
+                 sampling: 10
+      end
+
+      it "should have expected stoichiometry matrix" do
+        @sim.S.must_equal Matrix[ [-1, 0, 1] ].t
+        m = @sim.step!.marking
+        m[ 0 ].must_be_within_epsilon( 0.5, 1e-6 )
+        m[ 1 ].must_equal 2
+        m[ 2 ].must_be_within_delta( 3.5, 1e-9 )
+      end
+    end
+  end
+
+  describe "timed controlled isomerization" do
+    before do
+      @t3 = ::YPetri::Transition.new s: { @a => -1, @c => 1 },
+                                     domain: @b,
+                                     rate: λ { |a| a * 0.5 }
+      @net = ::YPetri::Net.new << @a << @b << @c << @t3
+      @sim = ::YPetri::TimedSimulation.new net: @net,
+               initial_marking: { @a => 1, @b => 0.6, @c => 3 },
+               step: 1,
+               sampling: 10,
+               target_time: 2
+    end
+
+    it "should exhibit correct behavior of #step" do
+      @sim.marking.must_equal [1.0, 0.6, 3.0]
+      @t3.stoichiometric?.must_equal true
+      @t3.timed?.must_equal true
+      @t3.has_rate?.must_equal true
+      @sim.gradient.must_equal Matrix.cv [-0.3, 0.0, 0.3]
+      @sim.Δ_Euler.must_equal Matrix.cv [-0.3, 0.0, 0.3]
+      @sim.step!
+      @sim.marking_vector.must_equal Matrix.cv [0.7, 0.6, 3.3]
+      @sim.euler_step!
+      @sim.run!
+      @sim.marking_vector.map( &[:round, 5] )
+        .must_equal Matrix.cv [0.4, 0.6, 3.6]
+    end
+  end
+end
+
+
+# **************************************************************************
+# Test of Workspace class.
+# **************************************************************************
+#
+describe ::YPetri::Workspace do
+  before do
+    # skip "to speed up testing"
+    @w = ::YPetri::Workspace.new
+    a = @w.Place.new!( default_marking: 1.0, name: "AA" )
+    b = @w.Place.new!( default_marking: 2.0, name: "BB" )
+    c = @w.Place.new!( ɴ: "CC", default_marking: 3.0 )
+    t1 = @w.Transition.new! s: { a => -1, b => -1, c => 1 },
+                            rate: 0.1,
+                            ɴ: "AA_BB_assembly"
+    t2 = @w.Transition.new! ɴ: "AA_appearing",
+                            codomain: a,
+                            rate: λ{ 0.1 },
+                            stoichiometry: 1
+    @pp, @tt = [a, b, c], [t1, t2]
+    @f_name = "test_output.csv"
+    @w.set_imc @pp.τBᴍHτ( &:default_marking )
+    @w.set_ssc step: 0.1, sampling: 10, target_time: 50
+    @w.set_cc( {} )
+    @sim = @w.new_timed_simulation
+    File.delete @f_name rescue nil
+  end
+
+  it "should present places, transitions, nets, simulations" do
+    assert_kind_of ::YPetri::Net, @w.Net::Top
+    assert_equal @pp[0], @w.place( "AA" )
+    assert_equal :AA, @w.p( @pp[0] )
+    assert_equal @tt[0], @w.transition( "AA_BB_assembly" )
+    assert_equal :AA_appearing, @w.t( @tt[1] )
+    assert_equal @pp, @w.places
+    assert_equal @tt, @w.transitions
+    assert_equal 1, @w.nets.size
+    assert_equal 1, @w.simulations.size
+    assert_equal 0, @w.cc.size
+    assert_equal 3, @w.imc.size
+    assert [0.1, 10, 50].each { |e| @w.ssc.include? e }
+    assert_equal @sim, @w.simulation
+    assert_equal [:Base], @w.clamp_collections.keys
+    assert_equal [:Base], @w.initial_marking_collections.keys
+    assert_equal [:Base], @w.simulation_settings_collections.keys
+    assert_equal [:AA, :BB, :CC], @w.pp
+    assert_equal [:AA_BB_assembly, :AA_appearing], @w.tt
+    assert_equal [:Top], @w.nn
+  end
+
+  it "should simulate" do
+    assert_equal 1, @w.simulations.size
+    assert_kind_of( ::YPetri::Simulation, @w.simulation )
+    assert_equal 2, @w.simulation.SR_transitions.size
+    @tt[0].domain.must_equal [ @pp[0], @pp[1] ]
+    @tt[1].domain.must_equal []
+    assert_equal [0.2, 0.1], @w.simulation.φ.column_to_a
+    @w.simulation.step!
+    @w.simulation.run!
+    rec_string = @w.simulation.recording_csv_string
+    expected_recording_string =
+      "0.0,1.0,2.0,3.0\n" +
+      "10.0,0.86102,0.86102,4.13898\n" +
+      "20.0,1.29984,0.29984,4.70016\n"
+    assert rec_string.start_with?( expected_recording_string )
+  end
+end
+
+# **************************************************************************
+# Test of Manipulator class.
+# **************************************************************************
+#
+describe ::YPetri::Manipulator do
+  before do
+    # skip "for now"
+    @m = ::YPetri::Manipulator.new
+  end
+  
+  it "has net basic points" do
+    # --- net point related assets ---
+    @m.net_point_reset
+    @m.net_point_to @m.workspace.net( :Top )
+    @m.net.must_equal @m.workspace.Net::Top
+    # --- simulation point related assets ---
+    @m.simulation_point_reset
+    @m.simulation_point_to nil
+    @m.simulation.must_equal nil
+    @m.simulation_point_position.must_equal nil
+    # --- cc point related assets ---
+    @m.cc_point_reset
+    @m.cc_point_to :Base
+    @m.cc.must_equal @m.workspace.clamp_collection
+    @m.cc.wont_equal :Base
+    @m.cc_point_position.must_equal :Base
+    # --- imc point related assets ---
+    @m.imc_point_reset
+    @m.imc_point_to :Base
+    @m.imc.must_equal @m.workspace.initial_marking_collection
+    @m.imc.wont_equal :Base
+    @m.imc_point_position.must_equal :Base
+    # --- ssc point related assets ---
+    @m.ssc_point_reset
+    @m.ssc_point_to :Base
+    @m.ssc.must_equal @m.workspace.simulation_settings_collection
+    @m.ssc.wont_equal :Base
+    @m.ssc_point_position.must_equal :Base
+  end
+
+  it "has basic selections" do
+    @m.net_selection_clear
+    @m.simulation_selection_clear
+    @m.cc_selection_clear
+    @m.imc_selection_clear
+    @m.ssc_selection_clear
+    @m.net_selection.must_equal []
+    @m.simulation_selection.must_equal []
+    @m.ssc_selection.must_equal []
+    @m.cc_selection.must_equal []
+    @m.imc_selection.must_equal []
+    [ :net, :simulation, :cc, :imc, :ssc ].each { |sym1|
+      [ :select!, :select, :unselect ].each { |sym2|
+        @m.must_respond_to "#{sym1}_#{sym2}"
+      }
+    }
+  end
+
+  it "presents some methods from workspace" do
+    [ @m.places, @m.transitions, @m.nets, @m.simulations ].map( &:size )
+      .must_equal [ 0, 0, 1, 0 ]
+    [ @m.clamp_collections,
+      @m.initial_marking_collections,
+      @m.simulation_settings_collections ].map( &:size ).must_equal [ 1, 1, 1 ]
+    [ @m.clamp_collections,
+      @m.initial_marking_collections,
+      @m.simulation_settings_collections ]
+    .map( &:keys ).must_equal [[:Base]] * 3
+    @m.pp.must_equal []
+    @m.tt.must_equal []
+    @m.nn.must_equal [ :Top ]       # ie. :Top net spanning whole workspace
+  end
+  
+  describe "slightly more complicated case" do
+    before do
+      @p = @m.Place ɴ: "P", default_marking: 1
+      @q = @m.Place ɴ: "Q", default_marking: 1
+      @decay_t = @m.Transition ɴ: "Tp", s: { P: -1 }, rate: 0.1
+      @constant_flux_t = @m.Transition ɴ: "Tq", s: { Q: 1 }, rate: λ{ 0.02 }
+      @m.initial_marking @p => 1.2
+      @m.initial_marking @q => 2
+      @m.set_step 0.01
+      @m.set_sampling 1
+      @m.set_time 30
+    end
+    
+    it "works" do
+      @m.run!
+      @m.simulation.places.must_equal [ @p, @q ]
+      @m.simulation.transitions.must_equal [ @decay_t, @constant_flux_t ]
+      @m.simulation.SR_tt.must_equal [ :Tp, :Tq ]
+      @m.simulation.sparse_stoichiometry_vector( :Tp )
+        .must_equal Matrix.column_vector( [-1, 0] )
+      @m.simulation.stoichiometry_matrix_for( @m.transitions ).column_size
+        .must_equal 2
+      @m.simulation.stoichiometry_matrix_for( @m.transitions ).row_size
+        .must_equal 2
+      @m.simulation.flux_vector.row_size.must_equal 2
+      # @m.plot_recording
+    end
+  end
+end
+
+
+# **************************************************************************
+# Test of YPetri class itself.
+# **************************************************************************
+#
+describe ::YPetri do
+  before do
+    # skip "to speed up testing"
+  end
+
+  it "should have basic classes" do
+    [ :Place, :Transition, :Net,
+      :Simulation, :TimedSimulation,
+      :Workspace, :Manipulator ].each { |ß|
+      assert_kind_of Module, ::YPetri.const_get( ß ) }
+  end
+end
+
+
+# **************************************************************************
+# ACCEPTANCE TESTS
+# **************************************************************************
+
+# describe "Token game" do
+#   before do
+#     @m = YPetri::Manipulator.new
+#     @m.Place name: "A"
+#     @m.Place name: "B"
+#     @m.Place name: "C", marking: 7.77
+#     @m.Transition name: "A2B", stoichiometry: { A: -1, B: 1 }
+#     @m.Transition name: "C_decay", stoichiometry: { C: -1 }, rate: 0.05
+#   end
+
+#   it "should work" do
+#     @m.place( :A ).marking = 2
+#     @m.place( :B ).marking = 5
+#     @m.places.map( &:name ).must_equal [:A, :B, :C]
+#     @m.places.map( &:marking ).must_equal [2, 5, 7.77]
+#     @m.transition( :A2B ).connectivity.must_equal [ @m.place( :A ), @m.place( :B ) ]
+#     @m.transition( :A2B ).fire!
+#     @m.places.map( &:marking ).must_equal [1, 6, 7.77]
+#     @m.transition( :A2B ).fire!
+#     @m.place( :A ).marking.must_equal 0
+#     @m.place( :B ).marking.must_equal 7
+#     2.times do @m.transition( :C_decay ).fire! 1 end
+#     @m.transition( :C_decay ).fire! 0.1
+#     200.times do @m.transition( :C_decay ).fire! 1 end
+#     assert_in_delta @m.place( :C ).marking, 0.00024, 0.00001
+#   end
+# end
+
+# describe "Basic use of TimedSimulation" do
+#   before do
+#     @m = YPetri::Manipulator.new
+#     @m.Place( name: "A", default_marking: 0.5 )
+#     @m.Place( name: "B", default_marking: 0.5 )
+#     @m.Transition( name: "A_pump",
+#                    stoichiometry: { A: -1 },
+#                    rate: proc { 0.005 } )
+#     @m.Transition( name: "B_decay",
+#                    stoichiometry: { B: -1 },
+#                    rate: 0.05 )
+#   end
+
+#   it "should work" do
+#     @m.net.must_be_kind_of ::YPetri::Net
+#     @m.run!
+#     @m.simulation.must_be_kind_of ::YPetri::TimedSimulation
+#     @m.plot_recording
+#     sleep 3
+#   end
+# end
+
+# describe "Graphviz visualization" do
+#   before do
+#     @m = YPetri::Manipulator.new
+#     @m.Place name: :A, m!: 1
+#     @m.Place name: :B, m!: 1.5
+#     @m.Place name: :C, m!: 2
+#     @m.Place name: :D, m!: 2.5
+#     @m.Transition name: :A_pump, s: { A: -1 }, rate: proc { 0.005 }
+#     @m.Transition name: :B_decay, s: { B: -1 }, rate: 0.05
+#     @m.Transition name: :C_guard, assignment: true, codomain: :C, action: λ { 2 }
+#   end
+
+#   it "should work" do
+#     @m.net.visualize
+#   end
+# end
+
+# describe "Simplified dTTP pathway used for demo with Dr. Chang" do
+#   before do
+#     @m = YPetri::Manipulator.new
+#     Cytoplasm_volume_in_litres = 5.0e-11
+#     NA = 6.022e23
+#     Pieces_per_micromolar = NA / 1_000_000 * Cytoplasm_volume_in_litres
+#     @m.set_step 60
+#     @m.set_sampling 300
+#     @m.set_target_time 60 * 60 * 2
+#     AMP = @m.Place( name: :AMP, m!: 8695.0 )
+#     ADP = @m.Place( name: :ADP, m!: 6521.0 )
+#     ATP = @m.Place( name: :ATP, m!: 3152.0 )
+#     Deoxycytidine = @m.Place( name: :Deoxycytidine, m!: 0.5 )
+#     DeoxyCTP = @m.Place( name: :DeoxyCTP, m!: 1.0 )
+#     DeoxyGMP = @m.Place( name: :DeoxyGMP, m!: 1.0 )
+#     UMP_UDP_pool = @m.Place( name: :UMP_UDP_pool, m!: 2737.0 )
+#     DeoxyUMP_DeoxyUDP_pool = @m.Place( name: :DeoxyUMP_DeoxyUDP_pool, m!: 0.0 )
+#     DeoxyTMP = @m.Place( name: :DeoxyTMP, m!: 3.3 )
+#     DeoxyTDP_DeoxyTTP_pool = @m.Place( name: :DeoxyTDP_DeoxyTTP_pool, m!: 5.0 )
+#     Thymidine = @m.Place( name: :Thymidine, m!: 0.5 )
+#     TK1 = @m.Place( name: :TK1, m!: 100_000 )
+#     TYMS = @m.Place( name: :TYMS, m!: 100_000 )
+#     RNR = @m.Place( name: :RNR, m!: 100_000 )
+#     TMPK = @m.Place( name: :TMPK, m!: 100_000 )
+#     TK1_kDa = 24.8
+#     TYMS_kDa = 66.0
+#     RNR_kDa = 140.0
+#     TMPK_kDa = 50.0
+#     TK1_a = 5.40
+#     TYMS_a = 3.80
+#     RNR_a = 1.00
+#     TMPK_a = 0.83
+#     @m.clamp AMP: 8695.0, ADP: 6521.0, ATP: 3152.0
+#     @m.clamp Deoxycytidine: 0.5, DeoxyCTP: 1.0, DeoxyGMP: 1.0
+#     @m.clamp Thymidine: 0.5
+#     @m.clamp UMP_UDP_pool: 2737.0
+#     # Functions
+#     Vmax_per_minute_per_enzyme_molecule =
+#       lambda { |enzyme_specific_activity_in_micromol_per_minute_per_mg,
+#                 enzyme_molecular_mass_in_kDa|
+#                   enzyme_specific_activity_in_micromol_per_minute_per_mg *
+#                     enzyme_molecular_mass_in_kDa }
+#     Vmax_per_minute =
+#       lambda { |specific_activity, kDa, enzyme_molecules_per_cell|
+#                Vmax_per_minute_per_enzyme_molecule.( specific_activity, kDa ) *
+#                  enzyme_molecules_per_cell }
+#     Vmax_per_second =
+#       lambda { |specific_activity, kDa, enzyme_molecules_per_cell|
+#                Vmax_per_minute.( specific_activity,
+#                                  kDa,
+#                                  enzyme_molecules_per_cell ) / 60 }
+#     Km_reduced =
+#       lambda { |km, ki_hash={}|
+#                ki_hash.map { |concentration, ci_Ki|
+#                              concentration / ci_Ki
+#                            }.reduce( 1, :+ ) * km }
+#     Occupancy =
+#       lambda { |concentration, reactant_Km, compet_inh_w_Ki_hash={}|
+#                concentration / ( concentration +
+#                                  Km_reduced.( reactant_Km,
+#                                               compet_inh_w_Ki_hash ) ) }
+#     MM_with_inh_micromolars_per_second =
+#       lambda { |reactant_concentration,
+#                 enzyme_specific_activity,
+#                 enzyme_mass_in_kDa,
+#                 enzyme_molecules_per_cell,
+#                 reactant_Km,
+#                 competitive_inh_w_Ki_hash={}|
+#                 Vmax_per_second.( enzyme_specific_activity,
+#                                   enzyme_mass_in_kDa,
+#                                   enzyme_molecules_per_cell ) *
+#                   Occupancy.( reactant_concentration,
+#                               reactant_Km,
+#                               competitive_inh_w_Ki_hash ) }
+#     MMi = MM_with_inh_micromolars_per_second
+#     TK1_Thymidine_Km = 5.0
+#     TYMS_DeoxyUMP_Km = 2.0
+#     RNR_UDP_Km = 1.0
+#     DNA_creation_speed = 3_000_000_000 / ( 12 * 3600 )
+#     TMPK_DeoxyTMP_Km = 12.0
+
+#     # transitions
+#     @m.Transition name: :TK1_Thymidine_DeoxyTMP,
+#                   domain: [ Thymidine, TK1, DeoxyTDP_DeoxyTTP_pool, DeoxyCTP, Deoxycytidine, AMP, ADP, ATP ],
+#                   stoichiometry: { Thymidine: -1, DeoxyTMP: 1 },
+#                   rate: proc { |rc, e, pool1, ci2, ci3, master1, master2, master3|
+#                                ci1 = pool1 * master3 / ( master2 + master3 )
+#                                MMi.( rc, TK1_a, TK1_kDa, e, TK1_Thymidine_Km,
+#                                      ci1 => 13.5, ci2 => 0.8, ci3 => 40.0 ) }
+#     @m.Transition name: :TYMS_DeoxyUMP_DeoxyTMP,
+#                   domain: [ DeoxyUMP_DeoxyUDP_pool, TYMS, AMP, ADP, ATP ],
+#                   stoichiometry: { DeoxyUMP_DeoxyUDP_pool: -1, DeoxyTMP: 1 },
+#                   rate: proc { |pool, e, master1, master2, master3|
+#                           rc = pool * master2 / ( master1 + master2 )
+#                           MMi.( rc, TYMS_a, TYMS_kDa, e, TYMS_DeoxyUMP_Km ) }
+#     @m.Transition name: :RNR_UDP_DeoxyUDP,
+#                   domain: [ UMP_UDP_pool, RNR, DeoxyUMP_DeoxyUDP_pool, AMP, ADP, ATP ],
+#                   stoichiometry: { UMP_UDP_pool: -1, DeoxyUMP_DeoxyUDP_pool: 1 },
+#                   rate: proc { |pool, e, master1, master2, master3|
+#                                rc = pool * master2 / ( master1 + master2 )
+#                                MMi.( rc, RNR_a, RNR_kDa, e, RNR_UDP_Km ) }
+#     @m.Transition name: :DNA_polymerase_consumption_of_DeoxyTTP,
+#                   stoichiometry: { DeoxyTDP_DeoxyTTP_pool: -1 },
+#                   rate: proc { DNA_creation_speed / 4 }
+#     @m.Transition name: :TMPK_DeoxyTMP_DeoxyTDP,
+#                   domain: [ DeoxyTMP, TMPK, ADP,
+#                             DeoxyTDP_DeoxyTTP_pool,
+#                             DeoxyGMP, AMP, ATP ],
+#                   stoichiometry: { DeoxyTMP: -1, TMPK: 0, DeoxyTDP_DeoxyTTP_pool: 1 },
+#                   rate: proc { |rc, e, ci1, pool, ci4, master1, master3|
+#                                master2 = ci1
+#                                ci2 = pool * master2 / ( master2 + master3 )
+#                                ci3 = pool * master3 / ( master2 + master3 )
+#                                MMi.( rc, TMPK_a, TMPK_kDa, e, TMPK_DeoxyTMP_Km,
+#                                      ci1 => 250.0, ci2 => 30.0, ci3 => 750, ci4 => 117 ) }
+#   end
+
+#   it "should work" do
+#     @m.run!
+#     @m.plot_recording
+#     sleep 3
+#   end
+# end
+
+# describe "Use of TimedSimulation with units" do
+#   before do
+#     require 'sy'
+
+#     @m = YPetri::Manipulator.new
+
+#     # === General assumptions
+#     Cytoplasm_volume = 5.0e-11.l
+#     Pieces_per_concentration = SY::Nᴀ * Cytoplasm_volume
+
+#     # === Simulation settings
+#     @m.set_step 60.s
+#     @m.set_target_time 10.min
+#     @m.set_sampling 120.s
+
+#     # === Places
+#     AMP = @m.Place m!: 8695.0.µM
+#     ADP = @m.Place m!: 6521.0.µM
+#     ATP = @m.Place m!: 3152.0.µM
+#     Deoxycytidine = @m.Place m!: 0.5.µM
+#     DeoxyCTP = @m.Place m!: 1.0.µM
+#     DeoxyGMP = @m.Place m!: 1.0.µM
+#     U12P = @m.Place m!: 2737.0.µM
+#     DeoxyU12P = @m.Place m!: 0.0.µM
+#     DeoxyTMP = @m.Place m!: 3.3.µM
+#     DeoxyT23P = @m.Place m!: 5.0.µM
+#     Thymidine = @m.Place m!: 0.5.µM
+#     TK1 = @m.Place m!: 100_000.unit.( SY::MoleAmount ) / Cytoplasm_volume
+#     TYMS = @m.Place m!: 100_000.unit.( SY::MoleAmount ) / Cytoplasm_volume
+#     RNR = @m.Place m!: 100_000.unit.( SY::MoleAmount ) / Cytoplasm_volume
+#     TMPK = @m.Place m!: 100_000.unit.( SY::MoleAmount ) / Cytoplasm_volume
+
+#     # === Enzyme molecular masses
+#     TK1_m = 24.8.kDa
+#     TYMS_m = 66.0.kDa
+#     RNR_m = 140.0.kDa
+#     TMPK_m = 50.0.kDa
+
+#     # === Specific activities of the enzymes
+#     TK1_a = 5.40.µmol.min⁻¹.mg⁻¹
+#     TYMS_a = 3.80.µmol.min⁻¹.mg⁻¹
+#     RNR_a = 1.00.µmol.min⁻¹.mg⁻¹
+#     TMPK_a = 0.83.µmol.min⁻¹.mg⁻¹
+
+#     # === Clamps
+#     @m.clamp AMP: 8695.0.µM, ADP: 6521.0.µM, ATP: 3152.0.µM
+#     @m.clamp Deoxycytidine: 0.5.µM, DeoxyCTP: 1.0.µM, DeoxyGMP: 1.0.µM
+#     @m.clamp Thymidine: 0.5.µM
+#     @m.clamp U12P: 2737.0.µM
+
+#     # === Function closures
+
+#     # Vmax of an enzyme.
+#     # 
+#     Vmax_enzyme = lambda { |specific_activity, mass, enzyme_conc|
+#       specific_activity * mass * enzyme_conc.( SY::Molecularity )
+#     }
+
+#     # Michaelis constant reduced for competitive inhibitors.
+#     # 
+#     Km_reduced = lambda { |km, ki_hash={}|
+#       ki_hash.map { |concentration, ci_Ki|
+#         concentration / ci_Ki }
+#         .reduce( 1, :+ ) * km
+#     }
+
+#     # Occupancy of enzyme active sites at given concentration of reactants
+#     # and competitive inhibitors.
+#     # 
+#     Occupancy = lambda { |ʀ_conc, ʀ_Km, cɪ_Kɪ={}|
+#       ʀ_conc / ( ʀ_conc + Km_reduced.( ʀ_Km, cɪ_Kɪ ) )
+#     }
+
+#     # Michaelis and Menten equation with competitive inhibitors.
+#     # 
+#     MMi = MM_equation_with_inhibitors = lambda {
+#       |ʀ_conc, ᴇ_specific_activity, ᴇ_mass, ᴇ_conc, ʀ_Km, cɪ_Kɪ={}|
+#       Vmax_enzyme.( ᴇ_specific_activity, ᴇ_mass, ᴇ_conc ) *
+#         Occupancy.( ʀ_conc, ʀ_Km, cɪ_Kɪ )
+#     }
+
+#     # === Michaelis constants of the enzymes involved.
+
+#     TK1_Thymidine_Km = 5.0.µM
+#     TYMS_DeoxyUMP_Km = 2.0.µM
+#     RNR_UDP_Km = 1.0.µM
+#     TMPK_DeoxyTMP_Km = 12.0.µM
+
+#     # === DNA synthesis speed.
+
+#     DNA_creation_speed = 3_000_000_000.unit.( SY::MoleAmount ) / 12.h / Cytoplasm_volume
+
+#     # === Transitions
+
+#     # Synthesis of TMP by TK1.
+#     # 
+#     TK1_Thymidine_DeoxyTMP = @m.Transition s: { Thymidine: -1, DeoxyTMP: 1 },
+#       domain: [ Thymidine, TK1, DeoxyT23P, DeoxyCTP, Deoxycytidine, AMP, ADP, ATP ],
+#         rate: proc { |rc, e, pool1, ci2, ci3, master1, master2, master3|
+#                 ci1 = pool1 * master3 / ( master2 + master3 )
+#                 MMi.( rc, TK1_a, TK1_m, e, TK1_Thymidine_Km,
+#                       ci1 => 13.5.µM, ci2 => 0.8.µM, ci3 => 40.0.µM )
+#               }
+
+#     # Methylation of DeoxyUMP into TMP by TYMS.
+#     TYMS_DeoxyUMP_DeoxyTMP = @m.Transition s: { DeoxyU12P: -1, DeoxyTMP: 1 },
+#       domain: [ DeoxyU12P, TYMS, AMP, ADP, ATP ],
+#         rate: proc { |pool, e, master1, master2, master3|
+#                 rc = pool * master2 / ( master1 + master2 )
+#                 MMi.( rc, TYMS_a, TYMS_m, e, TYMS_DeoxyUMP_Km )
+#               }
+
+#     # Reduction of UDP into DeoxyUDP by RNR.
+#     RNR_UDP_DeoxyUDP = @m.Transition s: { U12P: -1, DeoxyU12P: 1 },
+#       domain: [ U12P, RNR, DeoxyU12P, AMP, ADP, ATP ],
+#         rate: proc { |pool, e, master1, master2, master3|
+#                 rc = pool * master2 / ( master1 + master2 )
+#                 MMi.( rc, RNR_a, RNR_m, e, RNR_UDP_Km )
+#               }
+
+#     # Consumption of TTP by DNA synthesis.
+#     DeoxyTTP_to_DNA = @m.Transition s: { DeoxyT23P: -1 },
+#         rate: proc { DNA_creation_speed / 4 }
+
+#     # Phosphorylation of TMP into TDP-TTP pool.
+#     TMPK_DeoxyTMP_DeoxyTDP = @m.Transition s: { DeoxyTMP: -1, TMPK: 0, DeoxyT23P: 1 },
+#       domain: [ DeoxyTMP, TMPK, ADP, DeoxyT23P, DeoxyGMP, AMP, ATP ],
+#         rate: proc { |rc, e, ci1, pool, ci4, master1, master3|
+#                 master2 = ci1
+#                 ci2 = pool * master2 / ( master2 + master3 )
+#                 ci3 = pool * master3 / ( master2 + master3 )
+#                 MMi.( rc, TMPK_a, TMPK_m, e, TMPK_DeoxyTMP_Km,
+#                       ci1 => 250.0.µM, ci2 => 30.0.µM, ci3 => 750.µM, ci4 => 117.µM )
+#               }
+#   end
+
+#   it "should work" do
+#     # === Simulation execution
+#     @m.run!
+#     # === Plotting of the results
+#     @m.plot_recording
+#     sleep 20
+#   end
+# end