rmodbus 1.3.2 → 2.1.2

data/spec/tcp_client_spec.rb

@@ -1,88 +0,0 @@
-# -*- coding: ascii
-require 'rmodbus'
-
-describe ModBus::TCPClient do
-  describe "method 'query'" do    
-    before(:each) do
-      @uid = 1
-      @sock = double('Socket')
-      @adu = "\000\001\000\000\000\001\001"
-  
-      TCPSocket.should_receive(:new).with('127.0.0.1', 1502).and_return(@sock)
-      @sock.stub(:read).with(0).and_return('')
-      @cl = ModBus::TCPClient.new('127.0.0.1', 1502)
-      @slave = @cl.with_slave(@uid)
-    end
-    
-    it 'should send valid MBAP Header' do
-      @adu[0,2] = @slave.transaction.next.to_word
-      @sock.should_receive(:write).with(@adu)
-      @sock.should_receive(:read).with(7).and_return(@adu)
-      @slave.query('').should == nil
-    end
-    
-    it 'should not throw exception and white next packet if get other transaction' do
-      @adu[0,2] = @slave.transaction.next.to_word
-      @sock.should_receive(:write).with(@adu)
-      @sock.should_receive(:read).with(7).and_return("\000\002\000\000\000\001" + @uid.chr)
-      @sock.should_receive(:read).with(7).and_return("\000\001\000\000\000\001" + @uid.chr)
-
-      expect{ @slave.query('') }.to_not raise_error
-    end
-    
-    it 'should throw timeout exception if do not get own transaction' do
-      @slave.read_retries = 2
-      @adu[0,2] = @slave.transaction.next.to_word
-      @sock.should_receive(:write).at_least(1).times.with(/\.*/)
-      @sock.should_receive(:read).at_least(1).times.with(7).and_return("\000\x3\000\000\000\001" + @uid.chr)
-
-      expect{ @slave.query('') }.to raise_error(ModBus::Errors::ModBusTimeout, "Timed out during read attempt")
-    end
-
-    
-    it 'should return only data from PDU' do
-      request = "\x3\x0\x6b\x0\x3"
-      response = "\x3\x6\x2\x2b\x0\x0\x0\x64"
-      @adu = @slave.transaction.next.to_word + "\x0\x0\x0\x9" + @uid.chr + request
-      @sock.should_receive(:write).with(@adu[0,4] + "\0\6" + @uid.chr + request)
-      @sock.should_receive(:read).with(7).and_return(@adu[0,7])
-      @sock.should_receive(:read).with(8).and_return(response)
-  
-      @slave.query(request).should == response[2..-1]
-    end
-    
-    it 'should sugar connect method' do
-        ipaddr, port = '127.0.0.1', 502
-        TCPSocket.should_receive(:new).with(ipaddr, port).and_return(@sock)
-        @sock.should_receive(:closed?).and_return(false)
-        @sock.should_receive(:close)
-        ModBus::TCPClient.connect(ipaddr, port) do |cl|
-          cl.ipaddr.should == ipaddr
-          cl.port.should == port
-        end
-      end
-    
-    it 'should have closed? method' do
-      @sock.should_receive(:closed?).and_return(false)
-      @cl.closed?.should == false
-  
-      @sock.should_receive(:closed?).and_return(false)
-      @sock.should_receive(:close)
-  
-      @cl.close
-  
-      @sock.should_receive(:closed?).and_return(true)
-      @cl.closed?.should == true
-    end 
-    
-    it 'should give slave object in block' do
-      @cl.with_slave(1) do |slave|
-        slave.uid = 1
-      end
-    end
-  end  
-  
-  it "should tune connection timeout" do
-    lambda { ModBus::TCPClient.new('81.123.231.11', 1999, :connect_timeout => 0.001) }.should raise_error(ModBus::Errors::ModBusTimeout)
-  end
-end

data/spec/tcp_server_spec.rb

@@ -1,129 +0,0 @@
-# -*- coding: ascii
-require "rmodbus"
-
-describe ModBus::TCPServer do
-  before :all do
-    unit_ids = (1..247).to_a.shuffle
-    valid_unit_id = unit_ids.first
-    @invalid_unit_id = unit_ids.last
-    @server = ModBus::TCPServer.new(8502, valid_unit_id)
-    @server.coils = [1,0,1,1]
-    @server.discrete_inputs = [1,1,0,0]
-    @server.holding_registers = [1,2,3,4]
-    @server.input_registers = [1,2,3,4]
-    @server.start
-    @cl = ModBus::TCPClient.new('127.0.0.1', 8502)
-    @cl.read_retries = 1
-    @slave = @cl.with_slave(valid_unit_id)
-  end
-
-  it "should succeed if UID is broadcast" do
-    @cl.with_slave(0).read_coils(1,3)
-  end
-
-  it "should fail if UID is mismatched" do
-    lambda { @cl.with_slave(@invalid_unit_id).read_coils(1,3) }.should raise_exception(
-      ModBus::Errors::ModBusTimeout
-    )
-  end
-
-  it "should send exception if function not supported" do
-    lambda { @slave.query('0x43') }.should raise_exception(
-      ModBus::Errors::IllegalFunction,
-      "The function code received in the query is not an allowable action for the server"
-    )
-  end
-
-  it "should send exception if quanity of registers are more than 0x7d" do
-    lambda { @slave.read_holding_registers(0, 0x7e) }.should raise_exception(
-      ModBus::Errors::IllegalDataValue,
-      "A value contained in the query data field is not an allowable value for server"
-    )
-  end
-
-  it "shouldn't send exception if quanity of coils are more than 0x7d0" do
-    lambda { @slave.read_coils(0, 0x7d1) }.should raise_exception(
-      ModBus::Errors::IllegalDataValue,
-      "A value contained in the query data field is not an allowable value for server"
-    )
-  end
-
-  it "should send exception if addr not valid" do
-    lambda { @slave.read_coils(2, 8) }.should raise_exception(
-      ModBus::Errors::IllegalDataAddress,
-      "The data address received in the query is not an allowable address for the server"
-    )
-  end
-
-  it "should calc a many requests" do
-    @slave.read_coils(1,2)
-    @slave.write_multiple_registers(0,[9,9,9,])
-    @slave.read_holding_registers(0,3).should == [9,9,9]
-  end
-
-  it "should supported function 'read coils'" do
-    @slave.read_coils(0,3).should == @server.coils[0,3]
-  end
-
-  it "should supported function 'read coils' with more than 125 in one request" do
-    @server.coils = Array.new( 1900, 1 )
-    @slave.read_coils(0,1900).should == @server.coils[0,1900]
-  end
-
-  it "should supported function 'read discrete inputs'" do
-    @slave.read_discrete_inputs(1,3).should == @server.discrete_inputs[1,3]
-  end
-
-  it "should supported function 'read holding registers'" do
-    @slave.read_holding_registers(0,3).should == @server.holding_registers[0,3]
-  end
-
-  it "should supported function 'read input registers'" do
-    @slave.read_input_registers(2,2).should == @server.input_registers[2,2]
-  end
-
-  it "should supported function 'write single coil'" do
-    @server.coils[3] = 0
-    @slave.write_single_coil(3,1)
-    @server.coils[3].should == 1
-  end
-
-  it "should supported function 'write single register'" do
-    @server.holding_registers[3] = 25
-    @slave.write_single_register(3,35)
-    @server.holding_registers[3].should == 35
-  end
-
-  it "should supported function 'write multiple coils'" do
-    @server.coils = [1,1,1,0, 0,0,0,0, 0,0,0,0, 0,1,1,1]
-    @slave.write_multiple_coils(3, [1, 0,1,0,1, 0,1,0,1])
-    @server.coils.should == [1,1,1,1, 0,1,0,1, 0,1,0,1, 0,1,1,1]
-  end
-
-  it "should supported function 'write multiple registers'" do
-    @server.holding_registers = [1,2,3,4,5,6,7,8,9]
-    @slave.write_multiple_registers(3,[1,2,3,4,5])
-    @server.holding_registers.should == [1,2,3,1,2,3,4,5,9]
-  end
-
-  it "should have options :host" do
-    host = '192.168.0.1'
-    srv = ModBus::TCPServer.new(1010, 1, :host => '192.168.0.1')
-    srv.host.should eql(host)
-  end
-
-  it "should have options :max_connection" do
-    max_conn = 5
-    srv = ModBus::TCPServer.new(1010, 1, :max_connection => 5)
-    srv.maxConnections.should eql(max_conn)
-  end
-
-  after :all do
-    @cl.close unless @cl.closed?
-    @server.stop unless @server.stopped?
-    while GServer.in_service?(8502)
-      sleep(0.01)
-    end
-    @server.stop
-  end
-end