rbsim 0.0.3

data/spec/dsl/infrastructure_routes_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe "RBSim#dsl" do
+  context "model with routes" do
+
+    let :model do
+      RBSim.dsl do
+
+        route from: :node01, to: :node02, via: [ :net01, :net02 ]
+        route from: :node04, to: :node05, via: [ :net07, :net01 ], twoway: true
+        route from: :node06, to: :node07, via: [ :net07, :net01 ], twoway: :true
+
+      end
+    end
+
+    subject { model.routes }
+
+    it "has route from :node01 to :node02" do
+      expect(subject.find :node01, :node02).not_to be nil
+    end
+
+    it "has no route from :node02 to :node01" do
+      expect(subject.find :node02, :node01).to be nil
+    end
+
+    it "has route from :node04 to :node05" do
+      expect(subject.find :node04, :node05).not_to be nil
+    end
+
+    it "has route from :node05 to :node04" do
+      expect(subject.find :node05, :node04).not_to be nil
+    end
+
+    it "has route from :node06 to :node07" do
+      expect(subject.find :node06, :node07).not_to be nil
+    end
+
+    it "has route from :node07 to :node06" do
+      expect(subject.find :node07, :node06).not_to be nil
+    end
+
+
+  end
+end

data/spec/dsl/mapping_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper.rb'
+
+describe 'RBSim#dsl' do
+
+  context "with mapping" do
+
+    let(:model) do
+      RBSim.dsl do
+
+        put :client, on: :node01
+        put process: :worker1, on: :node01
+        put on: :node02, process: :worker2
+
+      end
+    end
+
+    it "has :client on :node01" do
+      expect(model.mapping[:client]).to eq :node01
+    end
+
+    it "has :worker1 on :node01" do
+      expect(model.mapping[:worker1]).to eq :node01
+    end
+
+    it "has :worker2 on :node02" do
+      expect(model.mapping[:worker2]).to eq :node02
+    end
+
+  end
+
+  context "with mapping without node" do
+    it "raises error" do
+      expect do
+        RBSim.dsl do
+          put :client
+        end
+      end.to raise_error RuntimeError
+    end
+  end
+
+  context "with mapping without process" do
+    it "raises error" do
+      expect do
+        RBSim.dsl do
+          put nil, on: :node01
+        end
+      end.to raise_error RuntimeError
+    end
+  end
+
+  context "with mapping defined by Hash without process" do
+    it "raises error" do
+      expect do
+        RBSim.dsl do
+          put on: :node01
+        end
+      end.to raise_error RuntimeError
+    end
+  end
+
+  context "with mapping defined by Hash without node" do
+    it "raises error" do
+      expect do
+        RBSim.dsl do
+          put process: :client
+        end
+      end.to raise_error RuntimeError
+    end
+  end
+end

data/spec/dsl/process_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper.rb'
+
+describe 'RBSim#dsl' do
+
+  shared_examples 'process defined' do
+
+    it "has one process" do
+      expect(model.processes.size).to eq(1)
+    end
+
+    it "has process :sender1" do
+      expect(model.processes[:sender1]).not_to be_nil
+    end
+
+    it "has 2 events in event_queue" do
+      expect(model.processes[:sender1].event_queue_size).to eq(2)
+    end
+  end
+
+  context "with processes defined by block" do
+
+    let(:model) do
+      RBSim.dsl do
+
+        new_process :sender1 do
+          delay_for time: 100
+          cpu do |cpu|
+            10000/cpu.performance
+          end
+        end
+
+      end
+    end
+
+    include_examples 'process defined'
+
+  end
+
+  context "with processes defined by program" do
+    let(:model) do
+      RBSim.dsl do
+        program :sender1_prg do |args|
+          delay_for time: args[:time]
+          cpu do |cpu|
+            args[:volume]/cpu.performance
+          end
+        end
+        new_process :sender1, program: :sender1_prg, args: { time: 100, volume: 10000 }
+      end
+    end
+
+    include_examples 'process defined'
+
+  end
+
+end

data/spec/dsl/program_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper.rb'
+
+describe 'RBSim#dsl' do
+
+  context "with two programs" do
+
+    let(:model) do
+      RBSim.dsl do
+
+        program :waiter do |time|
+          delay_for time: time
+        end
+
+        program :worker do |volume|
+          cpu do |cpu|
+            volume * volume / cpu.performance
+          end
+        end
+
+      end
+    end
+
+    it "has two programs" do
+      expect(model.programs.size).to eq(2)
+    end
+
+    it "has program called :waiter" do
+      expect(model.programs[:waiter]).not_to be_nil
+    end
+
+    it "has program called :volume" do
+      expect(model.programs[:worker]).not_to be_nil
+    end
+
+  end
+end

data/spec/dsl_and_hlmodel/new_process_spec.rb

@@ -0,0 +1,235 @@
+ require 'spec_helper'
+ require 'pry'
+
+# Test behavior of HLModel::Process created with
+# DSL new_process statement
+describe "HLModel::Process created with DSL#new_process" do
+
+  let :model do
+    RBSim.dsl do
+      new_process :worker do
+        stats_start tag: :work, group_name: 'worker1'
+        on_event :data do |volume|
+          delay_for 200
+          cpu do |c|
+            20/c.performance
+          end
+        end
+        delay_for 100
+        stats_stop tag: :work, group_name: 'worker1'
+        stats tag: :doing_something, group_name: 'worker1'
+        cpu do |cpu|
+          100/cpu.performance
+        end
+        new_process :child do
+          delay_for 400
+        end
+        register_event :data, args: 1000
+        send_data to: :child, size: 1024, type: :hello, content: "Hello!"
+        log "finished main, will serve events"
+      end
+    end
+  end
+
+  let :process do
+    p = model.processes[:worker]
+    p.node = :node01
+    p
+  end
+
+  module NewProcessSpec
+    class CPU
+      def performance
+        20
+      end
+    end
+  end
+
+  it "has correct behavior" do
+    expect(model.processes.size).to eq(1)
+
+    event = process.serve_system_event :stats_start
+    expect(event).to eq({name: :stats_start, args: { tag: :work, group_name: 'worker1'} })
+
+    event = process.serve_system_event :delay_for
+    expect(event).to eq({name: :delay_for, args: { time: 100 }})
+
+    event = process.serve_system_event :stats_stop
+    expect(event).to eq({name: :stats_stop, args: { tag: :work, group_name: 'worker1' } })
+
+    event = process.serve_system_event :stats
+    expect(event).to eq({name: :stats, args: { tag: :doing_something, group_name: 'worker1' } })
+
+    event = process.serve_system_event :cpu
+    expect(event[:name]).to eq(:cpu)
+    # CPU time computed for specified CPU
+    expect(event[:args][:block].call NewProcessSpec::CPU.new).to eq(5)
+
+    # new process
+    event = process.serve_system_event :new_process
+    new_process = event[:args][:constructor].call event[:args][:constructor_args]
+    expect(model.processes.size).to eq(2)
+    expect(model.processes[:child]).not_to be_nil
+    expect(model.processes[:child]).to eq(new_process)
+    # serve event of the new process
+    event = new_process.serve_system_event :delay_for
+    expect(event).to eq({name: :delay_for, args: { time: 400 }})
+
+
+    # old process again
+    # user register_event
+    expect {
+      e = process.serve_system_event :register_event
+      event = e[:args][:event]
+      delay = e[:args][:delay]
+      args = e[:args][:event_args]
+      expect(e[:name]).to eq(:register_event)
+      expect(event).to eq(:data)
+      expect(delay).to eq(0)
+      expect(args).to eq(1000)
+      process.enqueue_event(event, args)
+      #expect(process.event_queue_size).to eq(4)
+    }.not_to change(process, :event_queue_size) # register_event dequeued, new event enqueued
+
+
+    # send_data
+    event = process.serve_system_event :send_data
+    expect(event[:name]).to eq(:send_data)
+    # CPU time computed for specified CPU
+    expect(event[:args]).to eq(to: :child, size: 1024, type: :hello, content: "Hello!")
+
+    # log
+    event = process.serve_system_event :log
+    expect(event[:name]).to eq(:log)
+    expect(event[:args]).to eq("finished main, will serve events")
+
+
+
+    # user event :data registered by :register_event, its handler will be run
+    # in the future when time comes
+    p = process.serve_user_event
+    expect(p).to eq(process) # returns modified process
+
+    # Events created by serving the the :data user event above follow:
+    event = process.serve_system_event :delay_for
+    expect(event).to eq({name: :delay_for, args: { time: 200 }})
+
+    event = process.serve_system_event :cpu
+    expect(event[:name]).to eq(:cpu)
+    # CPU time computed for specified CPU
+    expect(event[:args][:block].call NewProcessSpec::CPU.new).to eq(1)
+
+
+  end
+
+  describe "#event_time" do
+    let :model do
+      RBSim.dsl do
+        new_process :worker do
+
+          on_event :start do
+            start_time = event_time
+            register_event :next_one, delay: 100.seconds
+          end
+
+          on_event :next_one do
+            next_time = event_time
+          end
+
+          register_event :start
+        end
+      end
+    end
+
+    it "returns time reported by simulator" do
+      simulator = double("simulator")
+      expect(simulator).to receive(:clock).twice
+      model.simulator = simulator
+
+      e = process.serve_system_event :register_event
+      process.enqueue_event e[:args][:event], e[:args][:event_args]
+
+      process.serve_user_event # :start
+
+      process.serve_system_event :register_event
+      process.enqueue_event e[:args][:event], e[:args][:event_args]
+
+      process.serve_user_event # :next_one
+    end
+
+  end
+
+  describe "#function statement" do
+    describe "defines function with access to variable values in correct context" do
+      let :model do
+        RBSim.dsl do
+          new_process :worker do
+            @variable = :initial_value
+
+            function :do_something do
+              log @variable
+            end
+
+            on_event :start do
+              do_something
+            end
+
+            register_event :start
+          end
+        end
+      end
+
+      it "function reads correct values from variables" do
+        e = process.serve_system_event :register_event
+        process.enqueue_event e[:args][:event], e[:args][:event_args]
+
+        # :start
+        process.serve_user_event
+
+        # value of variable logged by the function
+        e = process.serve_system_event :log
+
+        expect(e[:name]).to eq :log
+        expect(e[:args]).to eq :initial_value
+
+      end
+    end
+
+    describe "defines function with access to correct 'self'" do
+      let :model do
+        RBSim.dsl do
+          new_process :worker do
+
+            function :do_something do
+              self
+            end
+
+            on_event :start do
+              log self
+              log do_something
+            end
+
+            register_event :start
+          end
+        end
+      end
+
+      it "'self' in function equals to 'self' in calling block" do
+        e = process.serve_system_event :register_event
+        process.enqueue_event e[:args][:event], e[:args][:event_args]
+
+        # :start
+        process.serve_user_event
+
+        # values of variables 'self' 
+        # logged by the function...
+        log_function = process.serve_system_event :log
+        # ...and logged by the action handler block
+        log_block = process.serve_system_event :log
+
+        expect(log_function[:args].object_id).to eq log_block[:args].object_id
+      end
+    end
+
+  end
+end

data/spec/hlmodel/net_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+describe RBSim::HLModel::Net do
+  describe "drop decision" do
+    it "is always the same for two clones of the same net" do
+      net = RBSim::HLModel::Net.new :net01, 1024, 10, 0.5
+      equal_times = 1000.times.reduce(0) do |a,v|
+        net_clone = net.clone
+        if net.drop? == net_clone.drop?
+          a + 1
+        else
+          a
+        end
+      end
+      expect(equal_times).to eq 1000
+    end
+  end
+
+  describe "drop probability" do
+
+    it "defaults to 0" do
+      net = RBSim::HLModel::Net.new :net01, 1024, 10
+      expect(net.drop).to eq 0
+    end
+
+    it "can be 0" do
+      expect {
+        RBSim::HLModel::Net.new :net01, 1024, 10, 0
+      }.not_to raise_error
+    end
+
+    it "can be 1" do
+      expect {
+        RBSim::HLModel::Net.new :net01, 1024, 10, 1
+      }.not_to raise_error
+    end
+
+    it "can be 0.5" do
+      expect {
+        RBSim::HLModel::Net.new :net01, 1024, 10, 0.5
+      }.not_to raise_error
+    end
+
+    it "can be 0.3" do
+      expect {
+        RBSim::HLModel::Net.new :net01, 1024, 10, 0.3
+      }.not_to raise_error
+    end
+
+    it "cannot be 1.3" do
+      expect {
+        RBSim::HLModel::Net.new :net01, 1024, 10, 1.3
+      }.to raise_error
+    end
+
+    it "cannot be -1" do
+      expect {
+        RBSim::HLModel::Net.new :net01, 1024, 10, -1
+      }.to raise_error
+    end
+
+    it "can be a lambda" do
+      expect {
+        RBSim::HLModel::Net.new :net01, 1024, 10, -> { true }
+      }.not_to raise_error
+    end
+
+    it "can be a Proc" do
+      expect {
+        RBSim::HLModel::Net.new :net01, 1024, 10, Proc.new { true }
+      }.not_to raise_error
+    end
+
+    describe "given as float" do
+      it "drops all packets if euqlas 1" do
+        net = RBSim::HLModel::Net.new :net01, 1024, 10, 1
+        dropped = 100.times.reduce(0) { |a, v| net.drop? ? a + 1 : a }
+        expect(dropped).to eq 100
+      end
+
+      it "drops no packets if euqlas 1" do
+        net = RBSim::HLModel::Net.new :net01, 1024, 10, 0
+        dropped = 100.times.reduce(0) { |a, v| net.drop? ? a + 1 : a }
+        expect(dropped).to eq 0
+      end
+
+      it "drops half of the packets if euqlas 0.5" do
+        net = RBSim::HLModel::Net.new :net01, 1024, 10, 0.5
+        dropped = 1000.times.reduce(0) { |a, v| net.drop? ? a + 1 : a }
+        expect(dropped).to be_within(100).of(500)
+      end
+
+    end
+
+    describe "given as lambda" do
+      describe "if true" do
+        it "drops packet" do
+          net = RBSim::HLModel::Net.new :net01, 1024, 10, -> { true }
+          expect(net.drop?).to be true
+        end
+      end
+
+      describe "if false" do
+        it "does not drop packet" do
+          net = RBSim::HLModel::Net.new :net01, 1024, 10, -> { false }
+          expect(net.drop?).to be false
+        end
+      end
+
+    end
+  end
+end