fast-tcpn 0.0.5

data/spec/dsl/page_spec.rb

@@ -0,0 +1,195 @@
+require 'spec_helper'
+
+describe FastTCPN::DSL::PageDSL do
+  shared_examples "error handler" do
+    it "wraps error in DSLError " do
+      expect {
+        load_model
+      }.to raise_error FastTCPN::DSL::DSLError
+    end
+
+    it "includes page name in exception" do
+      expect {
+        load_model
+      }.to raise_error FastTCPN::DSL::DSLError, /Example TCPN Page/
+    end
+
+    it "includes original message in exception" do
+      expect {
+        load_model
+      }.to raise_error FastTCPN::DSL::DSLError, /An error occured/
+    end
+  end
+
+  shared_examples "nested error handler" do
+    it "includes subpage name in exception" do
+      expect {
+        load_model
+      }.to raise_error FastTCPN::DSL::DSLError, /A sub page/
+    end
+  end
+
+  describe "Error handling" do
+
+
+    describe "simple page" do
+      let :load_model do
+        FastTCPN.model do
+          page "Example TCPN Page" do
+            raise "An error occured"
+          end
+        end
+      end
+
+      it_behaves_like "error handler"
+    end
+
+    describe "nested page" do
+      let :load_model do
+        FastTCPN.model do
+          page "Example TCPN Page" do
+            page "A sub page" do
+              raise "An error occured"
+            end
+          end
+        end
+      end
+
+      it_behaves_like "error handler"
+      it_behaves_like "nested error handler"
+
+    end
+
+  end
+
+  describe "#place" do
+    let :model do
+      FastTCPN.model do
+        page "First page" do
+          p1 = place "input"
+        end
+      end
+    end
+    it "defines place in model" do
+      expect(model.find_place "input").to be_kind_of FastTCPN::Place
+    end
+  end
+
+  describe "#timed_place" do
+    let :model do
+      FastTCPN.model do
+        page "First page" do
+          p1 = timed_place "input"
+        end
+      end
+    end
+    it "defines timed place in model" do
+      expect(model.find_place "input").to be_kind_of FastTCPN::TimedPlace
+    end
+  end
+
+  describe "created by #read" do
+    include UsesTempFiles
+
+    in_directory_with_file "models/example.rb"
+
+    before do
+      content_for_file "models/example.rb", <<-EOF
+page "Example page" do
+  p1 = place "input"
+  p2 = place "output"
+end
+      EOF
+    end
+
+    let :model do
+      FastTCPN.read "models/example.rb"
+    end
+
+    it "has places defined in file" do
+      expect(model.find_place("input")).to be_kind_of FastTCPN::Place
+      expect(model.find_place("output")).to be_kind_of FastTCPN::Place
+    end
+
+  end
+
+  describe "#sub_page" do
+    describe "correctly handles errors" do
+      include UsesTempFiles
+
+      in_directory_with_file "models/top_page.rb"
+      in_directory_with_file "models/a_subpage.rb"
+
+      before do
+        content_for_file "models/top_page.rb", <<-EOF
+  page "Example TCPN Page" do
+    sub_page "a_subpage.rb"
+  end
+        EOF
+
+        content_for_file "models/a_subpage.rb", <<-EOF
+  page "A sub page" do
+    p1 = place "subpage place"
+    raise "An error occured"
+  end
+        EOF
+      end
+
+      let :load_model do
+        FastTCPN.read 'models/top_page.rb'
+      end
+
+      it_behaves_like "error handler"
+      it_behaves_like "nested error handler"
+    end
+
+    describe "correctly loads pages" do
+      include UsesTempFiles
+
+      in_directory_with_file "models/top_page.rb"
+      in_directory_with_file "models/a_subpage.rb"
+
+      before do
+        content_for_file "models/top_page.rb", <<-EOF
+  page "Example TCPN Page" do
+    sub_page "a_subpage.rb"
+    p1 = place "top page place"
+    transition "send" do
+      input p1
+    end
+  end
+        EOF
+
+        content_for_file "models/a_subpage.rb", <<-EOF
+  page "A sub page" do
+    p1 = place "sub page place"
+    transition "work" do
+      input p1
+    end
+  end
+        EOF
+      end
+
+      let :model do
+        FastTCPN.read 'models/top_page.rb'
+      end
+
+      it "has place from top page" do
+        expect(model.find_place("top page place")).to be_kind_of FastTCPN::Place
+      end
+
+      it "has place from sub page" do
+        expect(model.find_place("sub page place")).to be_kind_of FastTCPN::Place
+      end
+
+      it "has transition from top page" do
+        expect(model.find_transition("send")).to be_kind_of FastTCPN::Transition
+      end
+
+      it "has transition from sub page" do
+        expect(model.find_transition("work")).to be_kind_of FastTCPN::Transition
+      end
+    end
+
+  end
+end

data/spec/dsl/transition_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe FastTCPN::DSL::TransitionDSL do
+  let :model do
+
+    FastTCPN.model do
+      page "Test TCPN page" do
+        p1 = place :in
+        p2 = place :out
+        transition "work" do
+          input p1
+          output p2 do |binding, clock|
+            binding[:in]
+          end
+          sentry do |marking_for, clock, result|
+            result << { out: marking_for[:in] }
+          end
+        end
+      end
+    end
+
+  end
+
+  describe "defines transition" do
+    it "with name `work`" do
+      expect(model.find_transition("work")).not_to be_nil
+    end
+
+    it "with one input place" do
+      expect(model.find_transition("work").inputs_size).to eq 1
+    end
+    it "with out output place" do
+      expect(model.find_transition("work").outputs_size).to eq 1
+    end
+
+    it "with sentry" do
+      expect(model.find_transition("work").default_sentry?).to be false
+    end
+  end
+
+end

data/spec/hash_marking_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe FastTCPN::HashMarking do
+
+  let(:marking_class) { FastTCPN::HashMarking }
+
+  it_behaves_like 'hash marking'
+
+end

data/spec/place_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe "FastTCPN::Place" do
+
+  let(:place_class) { FastTCPN::Place }
+  let(:marking_class) { FastTCPN::HashMarking }
+  let(:keys) { { name: :name, valid: :valid? } }
+
+  it_behaves_like 'valid place'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,101 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter '/spec/'
+end
+
+
+require 'fast-tcpn'
+Dir["./spec/support/**/*.rb"].sort.each { |f| require f }
+
+# In specs we need full backtraces from simulation
+FastTCPN.debug = true
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+=begin
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

data/spec/support/hash_marking_shared.rb

@@ -0,0 +1,274 @@
+class Worker
+  attr_accessor :name
+  def initialize(name, finished, cpu = nil)
+    @name, @finished, @cpu = name, finished, cpu
+  end
+  def finished?
+    @finished
+  end
+
+  def cpu(value)
+    if @cpu == value
+      "yes"
+    else
+      "no"
+    end
+  end
+end
+
+shared_examples 'hash marking' do
+
+  describe "keys with params" do
+    let :marking do
+      marking_class.new name: :name, finished: :finished?, cpu_intel: [ :cpu, "intel" ]
+    end
+
+    subject { marking }
+
+    it "iterates over selected tokens" do
+      subject.add Worker.new("intel1", true, 'intel')
+      subject.add Worker.new("intel2", true, 'intel')
+      subject.add Worker.new("amd", true, 'amd')
+      expect(subject.each(:cpu_intel, 'yes').map { |t| t.value.name }).to match_array ["intel1", "intel2"]
+    end
+
+    it "works for empty marking" do
+      expect { 
+        subject.each(:cpu_intel, 'yes') do
+
+        end
+      }.not_to raise_error
+    end
+
+
+  end
+
+  let :marking do
+    marking_class.new name: :name, finished: :finished?
+  end
+
+  describe "without tokens" do
+    describe "#keys" do
+      shared_examples "keys defined in constructor" do
+        it "returns keys defined in constructor" do
+          expect(subject.keys[:name]).to eq :name
+          expect(subject.keys[:finished]).to eq :finished?
+        end
+      end
+      context "for just created marking" do
+        subject { marking }
+
+        include_examples "keys defined in constructor"
+
+        it "has 2 keys" do
+          expect(subject.keys.size).to eq 2
+        end
+
+      end
+
+      context "for marking with keys added later" do
+        subject do
+          marking.add_keys val: :something, valid: :valid?
+          marking
+        end
+
+        include_examples "keys defined in constructor"
+
+        it "has 4 keys" do
+          expect(subject.keys.size).to eq 4
+        end
+
+        it "returns the added keys" do
+          expect(subject.keys[:val]).to eq :something
+          expect(subject.keys[:valid]).to eq :valid?
+        end
+
+      end
+    end
+  end
+
+  describe "with tokens" do
+
+    let(:wget1) { Worker.new :wget1, true }
+    let(:wget2) { Worker.new :wget2, true }
+    let(:wget3) { Worker.new :wget3, false }
+
+    subject do
+      marking.add wget1
+      marking.add wget2
+      marking.add wget3
+      marking
+    end
+
+    it "iterates over all tokens" do
+      expect(subject.map { |t| t.value.name }).to match_array [wget1.name, wget2.name, wget3.name]
+    end
+
+    it "shuffles tokens for each iteration" do
+      list1 = subject.map { |t| t.value.name }
+      equal_lists = 0
+      10.times do
+        list2 = subject.map { |t| t.value.name }
+        expect(list1).to match_array list2
+        if list1 == list2
+          equal_lists += 1
+        end
+      end
+      expect(equal_lists).to be < 10
+    end
+
+    it "iterates over selected tokens" do
+      expect(subject.each(:finished, true).map { |t| t.value.name }).to match_array [wget1.name, wget2.name]
+    end
+
+    it "clones tokens before they are returned" do
+      expect(subject.each(:name, wget1.name).first.object_id).not_to eq(wget1.object_id)
+    end
+
+
+    describe "#add_keys" do
+      it "raises error" do
+        expect {
+          subject.add_keys val: :something, valid: :valid?
+        }.to raise_error FastTCPN::HashMarking::CannotAddKeys
+      end
+    end
+
+
+    describe "#delete" do
+      it "deletes tokens from 'name' list" do
+        expect {
+          subject.delete subject.each(:name, wget1.name).first
+        }.to change(subject, :size).by(-1)
+        expect(subject.each(:name, wget1.name).map { |t| t.value }).not_to include(wget1)
+      end
+
+      it "deletes from 'finished' list" do
+        expect {
+          subject.delete subject.each(:name, wget1.name).first
+        }.to change(subject, :size).by(-1)
+        expect(subject.each(:finished, wget1.finished?)).not_to include(wget1)
+      end
+
+      it "returns deleted token" do
+        to_delete = subject.each(:name, wget1.name).first
+        expect(subject.delete to_delete).to eq to_delete
+      end
+
+      it "returns nil if nothing was deleted" do
+        already_deleted = subject.delete subject.each(:name, wget1.name).first
+        expect(subject.delete already_deleted).to eq nil
+      end
+
+      context "with Array" do
+        it "deletes all tokens in the Array" do
+          tokens = []
+          tokens << subject.each(:name, wget1.name).first
+          tokens << subject.each(:name, wget2.name).first
+          expect {
+            subject.delete tokens
+          }.to change(subject, :size).by(-2)
+          expect(subject.each).not_to include(wget1)
+          expect(subject.each).not_to include(wget2)
+        end
+      end
+
+    end
+
+    describe "#get gets token from marking" do
+      let(:token) { subject.each.first }
+
+      it "equal to given token" do
+        expect(subject.get(token)).to eq token
+      end
+
+      it "clone of given token" do
+        expect(subject.get(token).object_id).not_to eq token.object_id
+      end
+
+      it "even if token value changed" do
+        token.value.name = "asdasd"
+        expect(subject.get(token)).to eq token
+      end
+
+      it "every time a new clone" do
+        token2 = subject.get(token)
+        expect(subject.get(token).object_id).not_to eq token2.object_id
+      end
+
+    end
+  end
+
+  describe "#add" do
+    it "extracts value from tokens of class extending this class" do
+      value = Worker.new("intel1", true, 'intel')
+      extended_token_class = Class.new subject.token_type
+      token = extended_token_class.new(value)
+      subject.add token
+      expect(subject.each.first.value.name).to eq value.name
+    end
+
+    describe "with Hash" do
+      it "adds token with value from :val key" do
+        value = Worker.new("intel1", true, 'intel')
+        subject.add val: value
+        expect(subject.each.first.value.name).to eq value.name
+      end
+    end
+
+    describe "with Array" do
+      it "adds all tokens from array" do
+        value1 = Worker.new("intel1", true, 'intel')
+        value2 = Worker.new("intel2", true, 'intel')
+        subject.add [ value1, value2 ]
+        expect(subject.map { |t| t.value.name }).to match_array ['intel1', 'intel2']
+      end
+      describe "of Hashes" do
+        it "adds all tokens from all Hashes in array" do
+        value1 = Worker.new("intel1", true, 'intel')
+        value2 = Worker.new("intel2", true, 'intel')
+        subject.add [ {val: value1}, {val: value2} ]
+        expect(subject.map { |t| t.value.name }).to match_array ['intel1', 'intel2']
+        end
+      end
+    end
+  end
+
+  it "works for Symbols" do
+    expect {
+      marking_class.new.add :asd
+    }.not_to raise_error
+  end
+
+  it "works for Procs" do
+    expect {
+      marking_class.new.add(proc {})
+    }.not_to raise_error
+  end
+
+  it "works for Fixnums" do
+    expect {
+      marking_class.new.add(123)
+    }.not_to raise_error
+  end
+
+  Klazz = Struct.new(:name, :id)
+  it "works for Structs" do
+    expect {
+      marking_class.new.add(Klazz.new)
+    }.not_to raise_error
+  end
+
+  it "works for anonymous Structs" do
+    expect {
+      marking_class.new.add(Struct.new(:name, :id).new)
+    }.not_to raise_error
+  end
+
+  it "works for nil" do
+    expect {
+      marking_class.new.add(nil)
+    }.not_to raise_error
+  end
+end
+