fast-tcpn 0.0.5

data/spec/tcpn_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+
+describe FastTCPN::TCPN do
+  shared_examples "place handler" do
+    context "if place does not exist" do
+
+      it "creates new place" do
+        expect {
+          subject.place "cpus", name: :name, node: :node
+        }.to change(subject, :places_count).by(1)
+      end
+
+      it "returns created place" do
+        p = subject.place "cpus", name: :name, node: :node
+        expect(p.name).to eq 'cpus'
+        expect(p.keys).to eq({ name: :name, node: :node })
+      end
+
+    end
+
+    context "if place exists" do
+
+      subject do
+        n = FastTCPN::TCPN.new
+        n.place "cpus", name: :name, node: :node
+        n
+      end
+
+      it "does not create place" do
+        expect {
+          subject.place "cpus", name: :name, node: :node
+        }.not_to change(subject, :places_count)
+      end
+
+      it "returns existing place" do
+        p = subject.place("cpus", valid: :valid?)
+        expect(p.kind_of? FastTCPN::Place).to be true
+        expect(p.name).to eq("cpus")
+      end
+
+      it "merges new keys of place with old ones" do
+        expect(subject.place("cpus", valid: :valid?).keys).to eq({ name: :name, node: :node, valid: :valid? })
+      end
+
+    end
+
+  end
+
+  describe "#place" do
+    it_behaves_like 'place handler'
+
+    it "creates Place" do
+      expect(subject.place("new one").class).to be FastTCPN::Place
+    end
+  end
+
+  describe "#timed_place" do
+    it_behaves_like 'place handler'
+
+    it "creates TimedPlace" do
+      expect(subject.timed_place("new one").class).to be FastTCPN::TimedPlace
+    end
+  end
+
+  describe "#find_place finds place by name" do
+
+    subject do
+      net = FastTCPN::TCPN.new
+      net.place "cpus", name: :name, node: :node
+      net.place "nodes", name: :name
+      net
+    end
+
+    it { expect(subject.find_place("cpus").name).to eq "cpus" }
+    it { expect(subject.find_place("nodes").name).to eq "nodes" }
+
+  end
+
+  describe "#transition" do
+    context "if transition does not exist" do
+      it "creates new transition" do
+        expect {
+          subject.transition(:cpu_working)
+        }.to change(subject, :transitions_count).by(1)
+      end
+
+      it "returns created transition" do
+        t = subject.transition(:cpu_working)
+        expect(t.kind_of? FastTCPN::Transition).to be true
+        expect(t.name).to eq :cpu_working
+      end
+    end
+
+    context "if transition exists" do
+      subject do
+        n = FastTCPN::TCPN.new
+        n.transition :cpu_working
+        n
+      end
+
+      it "does not create new transition" do
+        expect {
+          subject.transition(:cpu_working)
+        }.not_to change(subject, :transitions_count)
+      end
+
+      it "returns existing transition" do
+        t = subject.transition(:cpu_working)
+        expect(t.kind_of? FastTCPN::Transition).to be true
+        expect(t.name).to eq :cpu_working
+      end
+    end
+  end
+
+  describe "old API from tcpn gem" do
+    let :tcpn do
+      n = FastTCPN::TCPN.new
+      n.timed_place "cpus"
+      n
+    end
+
+    subject { tcpn }
+
+    describe "#add_marking_for" do
+      it "adds token for specified place" do
+        subject.add_marking_for 'cpus', 'cpu1'
+        expect(subject.find_place('cpus').marking.map {|t| t.value }).to eq ['cpu1']
+      end
+
+      it "adds timed token for specified place" do
+        subject.add_marking_for 'cpus', { val: 'cpu1', ts: 0 }
+        expect(subject.find_place('cpus').marking.map {|t| t.value }).to eq ['cpu1']
+        expect(subject.find_place('cpus').marking.map {|t| t.timestamp }).to eq [0]
+      end
+    end
+
+    describe "#marking_for" do
+      subject do
+        tcpn.find_place('cpus').add 'cpu1'
+        tcpn
+      end
+
+      it "returns correct token value for specified place" do
+        expect(subject.marking_for('cpus')).to eq [{ val: 'cpu1', ts: 0}]
+      end
+
+    end
+  end
+
+end

data/spec/timed_hash_marking_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+describe FastTCPN::TimedHashMarking do
+
+  let(:marking_class) { FastTCPN::TimedHashMarking }
+
+  let(:time) { 100 }
+
+  let(:active1) { Worker.new("active1", true) }
+  let(:active2) { Worker.new("active2", false) }
+  let(:waiting1) { Worker.new("waiting1", true) }
+  let(:waiting1_timestamp) { time + 100 }
+  let(:waiting2) { Worker.new("waiting2", false) }
+  let(:waiting2_timestamp) { time + 200 }
+
+  let :marking do
+    m = marking_class.new name: :name, finished: :finished?
+    m.add active1
+    m.add active2, time
+    m.add waiting1, waiting1_timestamp
+    m.add waiting1, waiting2_timestamp
+    m.time = time
+    m
+  end
+
+  subject { marking }
+
+  it_behaves_like 'hash marking'
+
+  it "stores current time" do
+    expect(subject.time).to eq time
+  end
+
+  it "does not allow to put back clock" do
+    expect { subject.time = time - 10 }.to raise_error FastTCPN::TimedHashMarking::InvalidTime
+  end
+
+  it "returns only active tokens" do
+    expect(subject.each.map { |t| t.value.name }).to match_array [ active1.name, active2.name ]
+  end
+
+  describe "returns waiting tokens when time comes"  do
+    subject do
+      marking.time = waiting1_timestamp
+      marking
+    end
+
+    it "without filter" do
+      expect(subject.each.map { |t| t.value.name }).to match_array [ active1.name, active2.name, waiting1.name ]
+    end
+
+    it "with name filter" do
+      expect(subject.each(:name, waiting1.name).first.value.name).to eq waiting1.name
+    end
+
+    it "with finished filter" do
+      expect(subject.each(:finished, true).map{ |t| t.value.name }).to match_array [ waiting1.name, active1.name ]
+    end
+  end
+
+  describe "#next_time" do
+    it "returns next time when a token may be available" do
+      expect(marking.next_time).to eq waiting1_timestamp
+      marking.time = waiting1_timestamp
+      expect(marking.next_time).to eq waiting2_timestamp
+    end
+
+    it "returns 0 if no token will be available in the future" do
+      marking.time = waiting2_timestamp
+      expect(marking.next_time).to eq 0
+    end
+
+    it "returns 0 for empty marking" do
+      marking = marking_class.new name: :name, finished: :finished?
+      expect(marking.next_time).to eq 0
+    end
+  end
+
+  describe "#add" do
+    it "uses token's timestamp for token" do
+      token = FastTCPN::TimedToken.new(Worker.new(:asd, true), 200)
+      expect {
+        marking.add token
+      }.not_to change(marking, :size)
+    end
+
+    it "uses given timestamp for object" do
+      expect {
+        marking.add Worker.new(:asd, true), time
+      }.to change(marking, :size).by(1)
+    end
+
+    describe "with Hash" do
+      let(:value) { Worker.new("new intel123", true, 'intel') }
+      subject do
+        marking = marking_class.new name: :name, finished: :finished?
+        marking.add val: value, ts: 100
+        marking.time = 100
+        marking
+      end
+
+      it "adds token with value from :val key" do
+        expect(subject.each.first.value.name).to eq value.name
+      end
+
+      it "adds token with timestamp from :ts key" do
+        expect(subject.each.first.timestamp).to eq 100
+      end
+
+    end
+
+    describe "with Hash in Array" do
+      let(:value1) { Worker.new("new intel123", true, 'intel') }
+      let(:value2) { Worker.new("new intel223", true, 'intel') }
+
+      subject do
+        marking = marking_class.new name: :name, finished: :finished?
+        marking.add [{ val: value1, ts: 100}, { val: value2, ts: 100}]
+        marking.time = 100
+        marking
+      end
+
+      it "adds all tokens from Array" do
+        expect(subject.map { |t| t.value.name }).to match_array [value1.name, value2.name]
+      end
+
+      it "added tokens have correct timestamp" do
+        expect(subject.map { |t| t.timestamp }).to match_array [100, 100]
+      end
+    end
+  end
+end

data/spec/timed_place_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe FastTCPN::TimedPlace do
+
+  let(:place_class) { FastTCPN::TimedPlace }
+  let(:marking_class) { FastTCPN::TimedHashMarking }
+  let(:keys) { { name: :name, valid: :valid? } }
+
+  it_behaves_like 'valid place'
+
+  subject do
+    place_class.new "cpu"
+  end
+
+  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 next_time to marking" do
+    expect(marking).to receive(:next_time).and_return(997)
+    expect(subject.next_time).to eq 997
+  end
+
+  it "passes time= to marking" do
+    expect(marking).to receive(:time=)
+    subject.time = 123
+  end
+
+  it "passes add with timestamp to marking" do
+    token = Worker.new(:asd, true)
+    expect(marking).to receive(:add).with(token, 100)
+    subject.add token, 100
+  end
+
+end

data/spec/timed_token_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe FastTCPN::TimedToken do
+
+  let(:token_class) { FastTCPN::TimedToken }
+  it_behaves_like 'token'
+
+  it "stores timestamp" do
+    t = token_class.new "asd", 100
+    expect(t.timestamp).to eq 100
+  end
+
+  it "has default timestamp seto to 0" do
+    t = token_class.new "asd"
+    expect(t.timestamp).to eq 0
+  end
+
+  describe "#==" do
+    it "does not care for timestamp" do
+      t1 = token_class.new "asd", 100
+      t2 = t1.clone
+      t2.timestamp = 200
+      expect(t1 == t2).to be true
+    end
+  end
+
+  describe "#with_timestamp" do
+    let(:t1) { token_class.new "asd", 100 }
+    let(:t2) { t1.with_timestamp 1000 }
+
+    it "returns token with the same value" do
+      expect(t2.value).to eq t1.value
+    end
+
+    it "returns token with new timestamp" do
+      expect(t2.timestamp).to eq 1000
+    end
+
+    it "returns token that is not equal to self" do
+      expect(t1 == t2).not_to be true
+    end
+  end
+
+  describe "#to_hash" do
+    it "returns valid reprsentation of token" do
+      expect(token_class.new(:asd, 200).to_hash).to eq({ val: :asd, ts: 200 })
+    end
+  end
+
+end

data/spec/token_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe FastTCPN::Token do
+
+  let(:token_class) { FastTCPN::Token }
+  it_behaves_like 'token'
+
+  describe "#to_hash" do
+    it "returns valid reprsentation of token" do
+      expect(token_class.new(:asd).to_hash).to eq({ val: :asd })
+    end
+  end
+end

data/spec/transition_spec.rb

@@ -0,0 +1,236 @@
+require 'spec_helper'
+
+describe FastTCPN::Transition do
+  let(:process) { :a_process }
+  let(:process2) { :a_process2 }
+  let(:process3) { :a_process3 }
+  let(:cpu) { :a_cpu }
+
+  let(:in1) do
+    p = FastTCPN::Place.new "process"
+    p.add process
+    p
+  end
+
+  let(:in2) do
+    p = FastTCPN::Place.new "cpu"
+    p.add cpu
+    p
+  end
+
+  let(:empty) do
+    p = FastTCPN::Place.new "empty"
+    p
+  end
+
+  let(:out) { FastTCPN::Place.new "output" }
+
+  let :transition do
+    t = FastTCPN::Transition.new :working
+    t.input in1
+    t.input in2
+    t
+  end
+
+  it "has name" do
+    expect(transition.name).to eq :working
+  end
+
+  describe "#fire" do
+    it "passes input tokens to sentry" do
+      transition.sentry do |marking_for, clock, result|
+        expect(marking_for[in1.name].each.first.value).to eq process
+        expect(marking_for[in2.name].each.first.value).to eq cpu
+      end
+      transition.fire
+    end
+
+    it "passes valid binding to output arc expression" do
+      transition.sentry do |marking_for, clock, result|
+        result << { in1.name => marking_for[in1.name].first, in2.name => marking_for[in2.name].first }
+      end
+      transition.output out do |binding|
+        expect(binding[in1.name].value).to eq process
+        expect(binding[in2.name].value).to eq cpu
+        binding[in1.name]
+      end
+      transition.fire
+    end
+
+    it "passes clock to sentry" do
+      transition.sentry do |marking_for, clock, result|
+        expect(clock).to eq 1000
+      end
+      transition.fire(1000)
+    end
+
+    it "passes clock to output arc expression" do
+      transition.sentry do |marking_for, clock, result|
+        result << { in1.name => marking_for[in1.name].first, in2.name => marking_for[in2.name].first }
+      end
+      transition.output out do |binding, clock|
+        expect(clock).to eq 1000
+        binding[in1.name]
+      end
+      transition.fire 1000
+    end
+
+    it "removes single tokens from input places and puts in output places" do
+      transition.sentry do |marking_for, clock, result|
+        result << { in1.name => marking_for[in1.name].first, in2.name => marking_for[in2.name].first }
+      end
+      transition.output out do |binding|
+        binding[in1.name]
+      end
+      transition.output in2 do |binding|
+        binding[in2.name]
+      end
+      transition.fire
+      expect(out.marking.each.map { |t| t.value }).to match_array [ process ]
+      expect(in2.marking.each.map { |t| t.value }).to match_array [ cpu ]
+    end
+
+    it "removes array of tokens from input places and puts in output places" do
+      in1.add process2
+      in1.add process3
+      transition.sentry do |marking_for, clock, result|
+        p1 = marking_for[in1.name].select { |t| t.value == process2 }.first
+        p2 = marking_for[in1.name].select { |t| t.value == process3 }.first
+        result << { in1.name => [p1, p2], in2.name => marking_for[in2.name].first }
+      end
+      transition.output out do |binding|
+        expect(binding[in1.name].map{ |t| t.value }).to eq [process2, process3]
+        binding[in1.name].first
+      end
+      transition.output in2 do |binding|
+        binding[in2.name]
+      end
+      transition.fire
+      expect(out.marking.each.map { |t| t.value }).to match_array [ process2 ]
+      expect(in2.marking.each.map { |t| t.value }).to match_array [ cpu ]
+    end
+
+    it "accepts nil as result of output arc expression" do
+      transition.sentry do |marking_for, clock, result|
+        result << { in1.name => marking_for[in1.name].first, in2.name => marking_for[in2.name].first }
+      end
+      transition.output out do |binding|
+        binding[in1.name]
+      end
+      transition.output in2 do |binding|
+        nil
+      end
+      transition.fire
+      expect(out.marking.each.map { |t| t.value }).to match_array [ process ]
+      expect(in2.marking).to be_empty
+    end
+
+
+    describe "default sentry" do
+      it "works correctly for empty input markings" do
+        transition = FastTCPN::Transition.new "disabled"
+        transition.input empty
+        transition.output out do |binding|
+          binding[empty.name]
+        end
+        expect(transition.fire).to be false
+      end
+
+      it "lets it fire for any tokens" do
+        transition.output out do |binding|
+          binding[in1.name]
+        end
+        transition.output in2 do |binding|
+          binding[in2.name]
+        end
+        expect(transition.fire).to be true
+        expect(in1.marking).to be_empty
+        expect(in2.marking).not_to be_empty
+        expect(out.marking).not_to be_empty
+      end
+
+      it "prevents firing transition if one of many input places is not marked" do
+        transition = FastTCPN::Transition.new "disabled"
+        transition.input in1
+        transition.input empty
+        transition.output out do |binding|
+          binding[empty.name]
+        end
+        expect(transition.fire).to be false
+
+      end
+    end
+
+    describe "#default_sentry?" do
+      it "is true if transition has no custom sentry" do
+        transition = FastTCPN::Transition.new "work"
+        expect(transition.default_sentry?).to be true
+      end
+      it "is false if transition has a custom sentry" do
+        transition = FastTCPN::Transition.new "work"
+        transition.sentry {}
+        expect(transition.default_sentry?).to be false
+      end
+    end
+
+    describe "#output" do
+      it "requires Place object as first parameter" do
+        expect { transition.output(:asd) {} }.to raise_error
+      end
+      it "requires block" do
+        expect { transition.output in1 }.to raise_error
+      end
+    end
+
+    describe "#inputs_size" do
+      it "counts input arcs" do
+        expect{
+          transition.input out
+        }.to change(transition, :inputs_size).from(2).to(3)
+      end
+    end
+
+    describe "#outputs_size" do
+      it "counts output arcs" do
+        expect{
+          transition.output(out) {}
+        }.to change(transition, :outputs_size).from(0).to(1)
+      end
+    end
+
+    describe "callbacks" do
+      let(:net) { double Object, call_callbacks: nil  }
+      let :transition do
+        t = FastTCPN::Transition.new :working, net
+        t.input in1
+        t.input in2
+        t
+      end
+
+      it "calls before callbacks on its net" do
+        expect(net).to receive(:call_callbacks).with(:transition, :before, anything()).once
+        transition.fire
+      end
+
+      it "calls after callbacks on its net" do
+        expect(net).to receive(:call_callbacks).with(:transition, :after, anything()).once
+        transition.fire
+      end
+    end
+
+    it "raises error if sentry puts in binding invalid object in place of token" do
+      transition.sentry do |marking_for, clock, result|
+        result << { in1.name => Object.new }
+      end
+      expect { transition.fire }.to raise_error FastTCPN::Transition::InvalidToken
+    end
+
+    it "raises error if sentry puts in binding token that not exists in place" do
+      transition.sentry do |marking_for, clock, result|
+        result << { in1.name => marking_for[in2.name].first }
+      end
+      expect { transition.fire }.to raise_error FastTCPN::Transition::InvalidToken
+    end
+  end
+
+end