fast-tcpn 0.0.5

data/spec/support/place_shared.rb

@@ -0,0 +1,66 @@
+shared_examples "valid place" do
+
+  it "has name" do
+    p = place_class.new "process"
+    expect(p.name).to eq "process"
+  end
+
+  it "passes keys to marking constructor" do
+    expect(marking_class).to receive(:new).with(keys)
+    place_class.new "processes", keys
+  end
+
+  describe "when created" do
+    subject do
+      place_class.new "processes", keys
+    end
+    let(:token) { "for this example just anything" }
+    let(:new_keys) { { node: :node_name, priority: :pri } }
+
+    let :marking do
+      marking = double(marking_class)
+      mc = class_double(marking_class).as_stubbed_const(:transfer_nested_constants => true)
+      allow(mc).to receive(:new).and_return(marking)
+      marking
+    end
+
+    it "passes add to marking" do
+      expect(marking).to receive(:add).with(token)
+      subject.add token
+    end
+
+    it "passes delete to marking" do
+      expect(marking).to receive(:delete).with(token)
+      subject.delete token
+    end
+
+    it "passes add_keys to marking" do
+      expect(marking).to receive(:add_keys).with(new_keys)
+      subject.add_keys new_keys
+    end
+
+    it "passes keys to marking" do
+      expect(marking).to receive(:keys)
+      subject.keys
+    end
+
+    describe "net callback" do
+      let(:net) { double Object, call_callbacks: nil  }
+      let :place do
+        place_class.new "process", {}, net
+      end
+
+      it "is called on :add" do
+        expect(net).to receive(:call_callbacks).with(:place, :add, anything())
+        place.add token
+      end
+
+      it "is called on :remove" do
+        expect(net).to receive(:call_callbacks).with(:place, :remove, anything())
+        allow(marking).to receive(:delete)
+        place.delete token
+      end
+    end
+  end
+
+end

data/spec/support/token_shared.rb

@@ -0,0 +1,27 @@
+shared_examples 'token' do
+
+  it "stores value" do
+    t = token_class.new "asd"
+    expect(t.value).to eq "asd"
+  end
+
+  describe "#==" do
+    it "is true for self" do
+      t = token_class.new "asd"
+      expect(t == t).to be true
+    end
+
+    it "is false for two different tokens, value does not matter" do
+      t1 = token_class.new "asd"
+      t2 = token_class.new "asd"
+      expect(t1 == t2).to be false
+    end
+
+    it "it true for clones" do
+      t1 = token_class.new "asd"
+      t2 = t1.clone
+      expect(t1 == t2).to be true
+    end
+  end
+
+end

data/spec/support/uses_temp_files.rb

@@ -0,0 +1,31 @@
+# taken from here:
+# http://gabebw.wordpress.com/2011/03/21/temp-files-in-rspec/
+module UsesTempFiles
+  def self.included(example_group)
+    example_group.extend(self)
+  end
+
+  def in_directory_with_file(file)
+    before do
+      @pwd = Dir.pwd if @pwd.nil?
+      @tmp_dir = File.join(File.dirname(__FILE__), 'tmp')
+      FileUtils.mkdir_p(@tmp_dir)
+      Dir.chdir(@tmp_dir)
+
+      FileUtils.mkdir_p(File.dirname(file))
+      FileUtils.touch(file)
+    end
+
+    define_method(:content_for_file) do |fname, content|
+      f = File.new(File.join(@tmp_dir, fname), 'a+')
+      f.write(content)
+      f.flush # VERY IMPORTANT
+      f.close
+    end
+
+    after do
+      Dir.chdir(@pwd)
+      FileUtils.rm_rf(@tmp_dir)
+    end
+  end
+end

data/spec/tcpn_binding_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe FastTCPN::TCPNBinding do
+
+  let :marking_for do
+    process = FastTCPN::HashMarking.new
+    process.add "process1"
+    process.add "process2"
+
+    cpu = FastTCPN::HashMarking.new
+    cpu.add "cpu1"
+    cpu.add "cpu2"
+
+    { process: process, cpu: cpu }
+  end
+
+  let :selected_process do
+    marking_for[:process].each.first
+  end
+
+  let :selected_cpu do
+    marking_for[:cpu].each.first
+  end
+
+  let :mapping do
+    { process: selected_process, cpu: selected_cpu }
+  end
+
+  subject do
+    FastTCPN::TCPNBinding.new mapping, marking_for
+  end
+
+  describe "returns new copy of token for given place" do
+    it "returns selected process" do
+      expect(subject[:process]).to eq selected_process
+    end
+
+    it "returns selected cpu" do
+      expect(subject[:cpu]).to eq selected_cpu
+    end
+
+  end
+
+  context "for array of tokens for a place" do
+    let :selected_process do
+      [ marking_for[:process].to_a[0],
+        marking_for[:process].to_a[1] ]
+    end
+    it "returns array of new copies of tokens for this place" do
+      expect(subject[:process]).to eq selected_process
+    end
+
+  end
+end

data/spec/tcpn_sim_spec.rb

@@ -0,0 +1,323 @@
+require 'spec_helper'
+
+describe FastTCPN::TCPN do
+  describe "#sim" do
+    AppProcess = Struct.new(:name)
+    CPU = Struct.new(:name, :process)
+
+    let(:net) do 
+      n = FastTCPN::TCPN.new
+      n
+    end
+
+    let(:process_count) { 10 }
+    let(:cpu_count) { 10 }
+
+    shared_examples "correctly moves tokens" do
+
+      it "removes all tokens from process" do
+        expect(process.marking.size).to eq 0
+      end
+
+      it "returns all tokens back to cpu" do
+        expect(cpu.marking.size).to eq cpu_count * process_count
+      end
+
+      it "leaves no tokens in out" do
+        expect(out.marking.size).to eq 0
+      end
+
+      it "puts all tokens in finished" do
+        expect(finished.marking.size).to eq process_count
+      end
+    end
+
+    context "without time" do
+
+      let(:process) { net.place :process, name: :name }
+      let(:cpu) { net.place :cpu, name: :name, process: :process }
+      let(:out) { net.place :out }
+      let(:finished) { net.place :finished }
+
+
+      before do
+        t1 = net.transition :work
+        t1.sentry do |marking_for, clock, result|
+          marking_for[:process].each do |p|
+            marking_for[:cpu].each(:process, p.value.name) do |c|
+              result << { process: p, cpu: c }
+            end
+          end
+        end
+        t1.input process
+        t1.input cpu
+        t1.output out do |binding|
+          binding[:process].value.name + "_done"
+        end
+        t1.output cpu do |binding|
+          binding[:cpu]
+        end
+
+        t2 = net.transition :finish
+        t2.input out
+        t2.output finished do |binding|
+          binding[:out]
+        end
+
+        process_count.times do |p|
+          process.add AppProcess.new(p.to_s)
+          cpu_count.times.map { |c| cpu.add CPU.new("CPU#{c}_#{p}", p.to_s) }
+        end
+
+        net.sim
+
+      end
+
+      include_examples "correctly moves tokens"
+
+    end
+
+    context "with time" do
+
+      let(:process) { net.timed_place :process, name: :name }
+      let(:cpu) { net.timed_place :cpu, name: :name, process: :process }
+      let(:out) { net.timed_place :out }
+      let(:finished) { net.timed_place :finished }
+
+      before do
+        t1 = net.transition :work
+        t1.sentry do |marking_for, clock, result|
+          marking_for[:process].each do |p|
+            marking_for[:cpu].each(:process, p.value.name) do |c|
+              result << { process: p, cpu: c }
+            end
+          end
+        end
+        t1.input process
+        t1.input cpu
+        t1.output out do |binding, clock|
+          { val: binding[:process].value.name + "_done", ts: clock + 10 }
+        end
+        t1.output cpu do |binding, clock|
+          binding[:cpu].with_timestamp clock + 100
+        end
+
+        t2 = net.transition :finish
+        t2.input out
+        t2.output finished do |binding, clock|
+          binding[:out].with_timestamp clock + 100
+        end
+
+        process_count.times do |p|
+          process.add AppProcess.new(p.to_s)
+          cpu_count.times.map { |c| cpu.add CPU.new("CPU#{c}_#{p}", p.to_s) }
+        end
+
+        net.sim
+
+      end
+
+      include_examples "correctly moves tokens"
+
+      it "sets correct timestamps of used cpus" do
+        used_cpus = cpu.marking.select { |token| token.timestamp == 100 }.length
+        expect(used_cpus).to eq process_count
+      end
+
+      it "sets correct timestamps on processes" do
+        finished.marking.each do |token|
+          expect(token.timestamp).to eq 110
+        end
+      end
+
+      it "stops at correct time" do
+        expect(net.clock).to eq 110
+      end
+
+    end
+
+
+    describe "error handling" do
+      let(:process) { tcpn.timed_place :process, name: :name }
+      let(:cpu) { tcpn.timed_place :cpu, name: :name, process: :process }
+      let(:out) { tcpn.timed_place :out }
+
+      let(:tcpn) do 
+        FastTCPN::TCPN.new
+      end
+
+      before do
+        t1 = tcpn.transition :work
+        t1.sentry &sentry
+        t1.input process
+        t1.input cpu
+        t1.output out, &out_output
+        t1.output cpu, &cpu_output
+
+        process.add AppProcess.new('process1')
+        cpu.add CPU.new("CPU1_process1", 'process1')
+      end
+
+      let(:sentry) do
+        proc do |marking_for, clock, result|
+          marking_for[:process].each do |p|
+            marking_for[:cpu].each(:process, p.value.name) do |c|
+              result << { process: p, cpu: c }
+            end
+          end
+        end
+      end
+
+      let(:out_output) do
+        proc do |binding, clock|
+          { val: binding[:process].value.name + "_done", ts: clock + 10 }
+        end
+      end
+
+      let(:cpu_output) do
+        proc do |binding, clock|
+          binding[:cpu].with_timestamp clock + 100
+        end
+      end
+
+      shared_examples 'error handler' do
+        it "raises TCPN::SimulationError" do
+          expect { tcpn.sim }.to raise_error FastTCPN::TCPN::SimulationError
+        end
+
+        context "when FastTCPN.debug is false" do
+          it "does not put FastTCPN files in backtrace" do
+            FastTCPN.debug = false
+            error_raised = false
+            begin
+              tcpn.sim
+            rescue FastTCPN::TCPN::SimulationError => e
+              error_raised = true
+              expect(e.backtrace.map { |b| b.sub /:.*$/,'' }.select{ |b| b =~ /\/lib\/fast-tcpn\// }).to be_empty
+              expect(e.backtrace).not_to be_empty
+            end
+            expect(error_raised).to be true
+          end
+        end
+
+        context "when FastTCPN.debug is true" do
+          it "puts FastTCPN files in backtrace" do
+            FastTCPN.debug = true
+            error_raised = false
+            begin
+              tcpn.sim
+            rescue FastTCPN::TCPN::SimulationError => e
+              error_raised = true
+              expect(e.backtrace.map { |b| b.sub /:.*$/,'' }.select{ |b| b =~ /\/lib\/fast-tcpn\// }).not_to be_empty
+            end
+            expect(error_raised).to be true
+          end
+        end
+      end
+
+      context "for invalid mapping from sentry" do
+        let(:sentry) do
+          proc do |marking_for, clock, result|
+            marking_for[:process].each do |p|
+              result << { process: p }
+            end
+          end
+        end
+
+        it_behaves_like 'error handler'
+      end
+
+      context "for NoMethodError inside simulator" do
+        let(:out_output) do
+          proc do |binding, clock|
+            { val: binding[:process].value.name.no_such_method_exists , ts: clock + 10 }
+          end
+        end
+
+        it_behaves_like 'error handler'
+      end
+
+    end
+  end
+
+  describe "#stop" do
+    AppProcess = Struct.new(:name)
+    CPU = Struct.new(:name, :process)
+
+    let(:net) do
+      n = FastTCPN::TCPN.new
+      n
+    end
+
+    let(:process_count) { 10 }
+    let(:cpu_count) { 10 }
+
+    let(:process) { net.place :process, name: :name }
+    let(:cpu) { net.place :cpu, name: :name, process: :process }
+    let(:out) { net.place :out }
+    let(:finished) { net.place :finished }
+
+
+    before do
+      t1 = net.transition :work
+      t1.sentry do |marking_for, clock, result|
+        marking_for[:process].each do |p|
+          marking_for[:cpu].each(:process, p.value.name) do |c|
+            result << { process: p, cpu: c }
+          end
+        end
+      end
+      t1.input process
+      t1.input cpu
+      t1.output out do |binding|
+        binding[:process].value.name + "_done"
+      end
+      t1.output cpu do |binding|
+        binding[:cpu]
+      end
+
+      t2 = net.transition :finish
+      t2.input out
+      t2.output finished do |binding|
+        binding[:out]
+      end
+
+      process_count.times do |p|
+        process.add AppProcess.new(p.to_s)
+        cpu_count.times.map { |c| cpu.add CPU.new("CPU#{c}_#{p}", p.to_s) }
+      end
+
+    end
+
+    it "stops running simulator" do
+      transitions = []
+      net.cb_for :transition, :after do |t, e|
+        transitions << e.transition
+        if transitions.size == 2
+          net.stop
+        end
+      end
+      net.sim
+      expect(transitions.size).to eq 2
+    end
+
+    describe "#stopped?" do
+      it "is true if simulation was stopped by #stop" do
+        transitions = []
+        net.cb_for :transition, :after do |t, e|
+          transitions << e.transition
+          if transitions.size == 2
+            net.stop
+          end
+        end
+        net.sim
+        expect(net.stopped?).to be true
+      end
+
+      it "is false if simulation finished without #stop" do
+        net.sim
+        expect(net.stopped?).to be false
+      end
+    end
+  end
+end