rmodbus-ccutrer 2.0.0 → 2.1.1

data/spec/exception_spec.rb

@@ -1,120 +0,0 @@
-# -*- coding: ascii
-require 'rmodbus'
-
-describe ModBus::TCPClient do
-  before(:all) do
-    @srv = ModBus::TCPServer.new(1502)
-    srv_slave = @srv.with_slave(1)
-    srv_slave.coils = [0] * 8
-    srv_slave.discrete_inputs = [0] * 8
-    srv_slave.holding_registers = [0] * 8
-    srv_slave.input_registers = [0] * 8
-    @srv.start
-
-    @cl = ModBus::TCPClient.new('127.0.0.1', 1502)
-    @slave = @cl.with_slave(1)
-  end
-
-  it "should raise ProxException" do
-    lambda { @slave.holding_registers[0..2] = [0,0] }.should raise_error(ModBus::Errors::ProxyException)
-  end
-
-  # Read coil status
-  it "should read coil status" do
-    @slave.read_coils(0, 4).should == [0] * 4
-  end
-
-  it "should raise exception if illegal data address" do
-   lambda { @slave.read_coils(501, 34) }.should raise_error(ModBus::Errors::IllegalDataAddress)
-  end
-
-  it "should raise exception if too many data" do
-   lambda { @slave.read_coils(0, 0x07D1) }.should raise_error(ModBus::Errors::IllegalDataValue)
-  end
-
-  # Read input status
-  it "should read discrete inputs" do
-    @slave.read_discrete_inputs(0, 4).should == [0] * 4
-  end
-
-  it "should raise exception if illegal data address" do
-   lambda { @slave.read_discrete_inputs(50, 23) }.should raise_error(ModBus::Errors::IllegalDataAddress)
-  end
-
-  it "should raise exception if too many data" do
-   lambda { @slave.read_discrete_inputs(0, 0x07D1) }.should raise_error(ModBus::Errors::IllegalDataValue)
-  end
-
-  # Read holding registers
-  it "should read discrete inputs" do
-    @slave.read_holding_registers(0, 4).should == [0, 0, 0, 0]
-  end
-
-  it "should raise exception if illegal data address" do
-   lambda { @slave.read_holding_registers(402, 99) }.should raise_error(ModBus::Errors::IllegalDataAddress)
-  end
-
-
-  it "should raise exception if too many data" do
-   lambda { @slave.read_holding_registers(0, 0x007E) }.should raise_error(ModBus::Errors::IllegalDataValue)
-  end
-
-  # Read input registers
-  it "should read discrete inputs" do
-    @slave.read_input_registers(0, 4).should == [0, 0, 0, 0]
-  end
-
-  it "should raise exception if illegal data address" do
-   lambda { @slave.read_input_registers(402, 9) }.should raise_error(ModBus::Errors::IllegalDataAddress)
-  end
-
-  it "should raise exception if too many data" do
-   lambda { @slave.read_input_registers(0, 0x007E) }.should raise_error(ModBus::Errors::IllegalDataValue)
-  end
-
-  # Force single coil
-  it "should force single coil" do
-    @slave.write_single_coil(4, 1).should == @slave
-    @slave.read_coils(4, 4).should == [1, 0, 0, 0] 
-  end
-
-  it "should raise exception if illegal data address" do
-   lambda { @slave.write_single_coil(501, true) }.should raise_error(ModBus::Errors::IllegalDataAddress)
-  end
-
-  # Preset single register
-  it "should preset single register" do
-    @slave.write_single_register(4, 0x0AA0).should == @slave
-    @slave.read_holding_registers(4, 1).should == [0x0AA0] 
-  end
-
-  it "should raise exception if illegal data address" do
-   lambda { @slave.write_single_register(501, 0x0AA0) }.should raise_error(ModBus::Errors::IllegalDataAddress)
-  end
-
-  # Force multiple coils
-  it "should force multiple coils" do
-    @slave.write_multiple_coils(4, [0,1,0,1]).should == @slave
-    @slave.read_coils(3, 5).should == [0,0,1,0,1]
-  end
-
-  it "should raise exception if illegal data address" do
-   lambda { @slave.write_multiple_coils(501, [1,0]) }.should raise_error(ModBus::Errors::IllegalDataAddress)
-  end
-
-  # Preset multiple registers
-  it "should preset multiple registers" do
-    @slave.write_multiple_registers(4, [1, 2, 3, 0xAACC]).should == @slave
-    @slave.read_holding_registers(3, 5).should == [0, 1, 2, 3, 0xAACC] 
-  end
-
-  it "should raise exception if illegal data address" do
-   lambda { @slave.write_multiple_registers(501, [1, 2]) }.should raise_error(ModBus::Errors::IllegalDataAddress)
-  end
-
-  after(:all) do
-    @cl.close unless @cl.closed?
-    @srv.stop
-  end
-
-end

data/spec/ext_spec.rb

@@ -1,52 +0,0 @@
-# -*- coding: ascii
-require 'rmodbus'
-
-describe Array do
-  before do
-    @arr = [1,0,1,1, 0,0,1,1, 1,1,0,1, 0,1,1,0,  1,0,1]
-    @test = [0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0]
-  end
-
-  it "should return string reprisent 16bit" do
-    @arr.pack_to_word.should == "\xcd\x6b\x5" 
-  end
-
-  it "fixed bug for	divisible 8 data " do
-    ([0] * 8).pack_to_word.should == "\x00"
-  end
-  
-  it "should unpack to @test" do
-    "test".unpack_bits == @test
-  end
-
-  it "should turn an array into 32b ints" do
-    [20342, 17344].to_32i.should == [1136676726]
-    [20342, 17344, 20342, 17344].to_32i.size.should == 2
-  end
-
-  it "should turn an array into 32b floats big endian" do
-    [20342, 17344].to_32f[0].should be_within(0.1).of(384.620788574219)
-    [20342, 17344, 20342, 17344].to_32f.size.should == 2
-  end
-  
-  it "should turn a an array into 32b floats (little endian)" do
-    [17344, 20342].to_32f_le[0].should be_within(0.1).of(384.620788574219)
-    [17344, 20342, 17344, 20342].to_32f_le.size.should == 2
-  end
-
-  it "should turn an array from 32b ints into 16b ints, big endian" do
-    [1136676726].from_32i.should == [20342, 17344]
-    [1136676726, 1136676725].from_32i.should == [20342, 17344, 20341, 17344]
-  end
-
-  it "should turn an array from 32b floats into 16b ints, big endian" do
-    [384.620788].from_32f.should == [20342, 17344]
-    [384.620788, 384.620788].from_32f.should == [20342, 17344, 20342, 17344]
-  end
-
-  it "should raise exception if uneven number of elements" do
-   lambda { [20342, 17344, 123].to_32f }.should raise_error(StandardError)
-   lambda { [20342, 17344, 123].to_32i }.should raise_error(StandardError)
-  end
-end
-

data/spec/logging_spec.rb

@@ -1,89 +0,0 @@
-# -*- coding: ascii
-require 'rmodbus'
-
-describe ModBus::TCPClient  do
-  before(:each) do
-    @uid = 1
-    @sock = double('Socket')
-    @adu = "\000\001\000\000\000\001\001"
-
-    Socket.should_receive(:tcp).with('127.0.0.1', 1502, nil, nil, hash_including(:connect_timeout)).and_return(@sock)
-    @sock.stub(:read).with(0).and_return('')
-
-    @slave = ModBus::TCPClient.new('127.0.0.1', 1502).with_slave(@uid)
-    @slave.debug = true
-  end
-
-  it 'should log rec\send bytes' do
-    request, response = "\x3\x0\x6b\x0\x3", "\x3\x6\x2\x2b\x0\x0\x0\x64"
-    mock_query(request,response)
-    $stdout.should_receive(:puts).with("Tx (12 bytes): [00][01][00][00][00][06][01][03][00][6b][00][03]")
-    $stdout.should_receive(:puts).with("Rx (15 bytes): [00][01][00][00][00][09][01][03][06][02][2b][00][00][00][64]")
-    @slave.query(request)
-  end
-
-  it "should don't logging if debug disable" do
-    @slave.debug = false
-    request, response = "\x3\x0\x6b\x0\x3", "\x3\x6\x2\x2b\x0\x0\x0\x64"
-    mock_query(request,response)
-    @slave.query(request)
-  end
-
-  it "should log warn message if transaction mismatch" 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)
-
-    $stdout.should_receive(:puts).with("Tx (7 bytes): [00][01][00][00][00][01][01]")
-    $stdout.should_receive(:puts).with("Rx (7 bytes): [00][02][00][00][00][01][01]")
-    $stdout.should_receive(:puts).with("Transaction number mismatch. A packet is ignored.")
-    $stdout.should_receive(:puts).with("Rx (7 bytes): [00][01][00][00][00][01][01]")
-
-    @slave.query('')
-  end
-
-  def mock_query(request, response)
-    @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)
-  end
-end
-
-begin
-  require "serialport"
-  describe ModBus::RTUClient do
-    before do 
-      @sp = double('Serial port')
-
-      SerialPort.should_receive(:new).with("/dev/port1", 9600, 7, 2, SerialPort::ODD).and_return(@sp)
-      SerialPort.stub(:public_method_defined?).with(:flush_input).and_return(true)
-
-      @sp.stub(:class).and_return(SerialPort)
-      @sp.should_receive(:flow_control=).with(SerialPort::NONE)
-      @sp.stub(:read_timeout=)
-      @sp.stub(:flush_input)
-
-      @slave = ModBus::RTUClient.new("/dev/port1", 9600, :data_bits => 7, :stop_bits => 2, :parity => SerialPort::ODD).with_slave(1)
-      @slave.read_retries = 0
-
-    end
-    
-    it 'should log rec\send bytes' do
-      request = "\x3\x0\x1\x0\x1"
-      @sp.should_receive(:write).with("\1#{request}\xd5\xca")
-      @sp.should_receive(:flush_input)  # Clean a garbage
-      @sp.should_receive(:read).with(2).and_return("\x1\x3")
-      @sp.should_receive(:read).with(1).and_return("\x2")
-      @sp.should_receive(:read).with(4).and_return("\xff\xff\xb9\xf4")
-      
-      @slave.debug = true
-      $stdout.should_receive(:puts).with("Tx (8 bytes): [01][03][00][01][00][01][d5][ca]")
-      $stdout.should_receive(:puts).with("Rx (7 bytes): [01][03][02][ff][ff][b9][f4]")
-      
-      @slave.query(request).should == "\xff\xff"
-    end
-  end
-rescue LoadError
-end

data/spec/proxy_spec.rb

@@ -1,74 +0,0 @@
-# -*- coding: ascii
-require 'rmodbus'
-
-describe Array do
-  before do
-    @slave = double('ModBus Slave')
-    @coil_proxy = ModBus::ReadWriteProxy.new(@slave, :coil)
-    @discrete_input_proxy = ModBus::ReadOnlyProxy.new(@slave, :discrete_input)
-    @holding_register_proxy = ModBus::ReadWriteProxy.new(@slave, :holding_register)
-    @input_register_proxy = ModBus::ReadOnlyProxy.new(@slave, :input_register)
-  end
-
-  # Handle all of the coil methods
-  it "should call read_coil" do
-    @slave.should_receive(:read_coil).with(0, 1)
-    @coil_proxy[0]
-  end
-  it "should call read_coils" do
-    @slave.should_receive(:read_coils).with(0, 2)
-    @coil_proxy[0..1]
-  end
-  it "should call write_coil" do
-    @slave.should_receive(:write_coil).with(0, 1)
-    @coil_proxy[0] = 1
-  end
-  it "should call write_coils" do
-    @slave.should_receive(:write_coils).with(0, [0, 0])
-    @coil_proxy[0..1] = [0, 0]
-  end
-
-
-  # Discrete input tests
-  it "should call read_discrete_input" do
-    @slave.should_receive(:read_discrete_input).with(0, 1)
-    @discrete_input_proxy[0]
-  end
-
-  it "should call read_discrete_inputs" do
-    @slave.should_receive(:read_discrete_inputs).with(0, 2)
-    @discrete_input_proxy[0..1]
-  end
-
-
-  # Holding Register Tess
-  it "should call read_holding_register" do
-    @slave.should_receive(:read_holding_register).with(0, 1)
-    @holding_register_proxy[0]
-  end
-  it "should call read_holding_registers" do
-    @slave.should_receive(:read_holding_registers).with(0, 2)
-    @holding_register_proxy[0..1]
-  end
-  it "should call write_holding_register" do
-    @slave.should_receive(:write_holding_register).with(0, 1)
-    @holding_register_proxy[0] = 1
-  end
-  it "should call write_holding_registers" do
-    @slave.should_receive(:write_holding_registers).with(0, [0, 0])
-    @holding_register_proxy[0..1] = [0, 0]
-  end
-
-
-  # Input Register Tests
-  it "should call read_discrete_input" do
-    @slave.should_receive(:read_input_register).with(0, 1)
-    @input_register_proxy[0]
-  end
-
-  it "should call read_discrete_inputs" do
-    @slave.should_receive(:read_input_registers).with(0, 2)
-    @input_register_proxy[0..1]
-  end
-end
-

data/spec/read_rtu_response_spec.rb

@@ -1,92 +0,0 @@
-# -*- coding: ascii
-require 'rmodbus'
-
-#Use public wrap method
-class ModBus::Client
-  include ModBus::RTU
-  def test_read_method(msg)
-    io = TestIO.new(msg)
-    read_rtu_response(io)
-  end
-
-end
-
-class TestIO
-  def initialize(msg)
-    @msg = msg
-  end
-
-  def read(num)
-    result = @msg[0,num]
-    @msg = @msg[num..-1]
-    result
-  end
-end
-
-describe "#read_rtu_response" do
-  before do
-    @cl_mb = ModBus::Client.new   
-  end
-
-  it "should read response for 'read coils'" do
-    resp = make_resp("\x1\x3\xcd\x6b\x05")
-    @cl_mb.test_read_method(resp).should == resp 
-  end
-
-  it "should read response for 'read discrete inputs'" do
-    resp = make_resp("\x2\x3\xac\xdb\x35")
-    @cl_mb.test_read_method(resp).should == resp 
-  end
-
-  it "should read response for 'read holding registers'" do
-    resp = make_resp("\x3\x6\x2\x2b\x0\x0\x0\x64")
-    @cl_mb.test_read_method(resp).should == resp 
-  end
-
-  it "should read response for 'read input registers'" do
-    resp = make_resp("\x4\x2\x0\xa")
-    @cl_mb.test_read_method(resp).should == resp 
-  end
-
-  it "should read response for 'write single coil'" do
-    resp = make_resp("\x5\x0\xac\xff\x0")
-    @cl_mb.test_read_method(resp).should == resp 
-  end
-
-  it "should read response for 'write single register'" do
-    resp = make_resp("\x6\x0\x1\x0\x3")
-    @cl_mb.test_read_method(resp).should == resp 
-  end
-
-  it "should read response for 'write multiple coils'" do
-    resp = make_resp("\xf\x0\x13\x0\xa")
-    @cl_mb.test_read_method(resp).should == resp 
-  end
-
-  it "should read response for 'write multiple registers'" do
-    resp = make_resp("\x10\x0\x1\x0\x2")
-    @cl_mb.test_read_method(resp).should == resp 
-  end
-
-  it "should read response 'mask write register'" do
-    resp = make_resp("\x16\x0\x4\x0\xf2\x0\x25")
-    @cl_mb.test_read_method(resp).should == resp 
-  end
-
-  it "should read exception codes" do
-    resp = make_resp("\x84\x3")
-    @cl_mb.test_read_method(resp).should == resp 
-  end
-
-  it "should raise exception if function is illegal" do
-    resp =  make_resp("\x1f\x0\x1\x0\x2")
-    lambda{ @cl_mb.test_read_method(resp)}.should raise_error {
-      ModBus::Errors::IllegalFunction
-    }
-  end
-
-  def make_resp(msg)
-    "\x1" + msg + "\x2\x2" # slave + msg + mock_crc
-  end
-end
-

data/spec/response_mismach_spec.rb

@@ -1,163 +0,0 @@
-# -*- coding: ascii
-require "spec_helper"
-
-describe "response mismach" do
-  include RaiseResponseMatcher
-  before(:each) do
-    @slave = ModBus::Client::Slave.new(1, nil)
-    @slave.raise_exception_on_mismatch = true
-  end
-
-  it "should raise error if function code is mismatch" do
-    request = "\x1\x0\x13\x0\x12"
-    response = "\x2\x3\xcd\xb6\x5"
-    mock_query!(request, response)
-
-    lambda{ @slave.read_coils(0x13,0x12) }.should raise_response_mismatch(
-      "Function code is mismatch (expected 1, got 2)",
-      request, response)
-  end
-
-  describe "read coils" do
-    it "should raise error if count of byte is mismatch" do
-      request = "\x1\x0\x13\x0\x12"
-      response = "\x1\x2\xcd\xb6"
-      mock_query!(request, response)
-
-      lambda{ @slave.read_coils(0x13,0x12) }.should raise_response_mismatch(
-        "Byte count is mismatch (expected 3, got 2 bytes)",
-        request, response)
-    end
-  end
-
-  describe "read discrete inputs" do
-    it "should raise error if count of byte is mismatch" do
-      request = "\x2\x0\x13\x0\x12"
-      response = "\x2\x2\xcd\xb6"
-      mock_query!(request, response)
-
-      lambda{ @slave.read_discrete_inputs(0x13,0x12) }.should raise_response_mismatch(
-        "Byte count is mismatch (expected 3, got 2 bytes)",
-        request, response)
-    end
-  end
-
-  describe "read holding registesrs" do
-    it "should raise error if count of registers is mismatch" do
-      request = "\x3\x0\x8\x0\x1"
-      response = "\x3\x4\x0\xa\x0\xb"
-      mock_query!(request, response)
-
-      lambda{ @slave.read_holding_registers(0x8,0x1) }.should raise_response_mismatch(
-        "Register count is mismatch (expected 1, got 2 regs)",
-        request, response)
-    end
-  end
-
-  describe "read input registesrs" do
-    it "should raise error if count of registers is mismatch" do
-      request = "\x4\x0\x8\x0\x2"
-      response = "\x4\x2\xa\x0"
-      mock_query!(request, response)
-
-      lambda{ @slave.read_input_registers(0x8,0x2) }.should raise_response_mismatch(
-        "Register count is mismatch (expected 2, got 1 regs)",
-        request, response)
-    end
-  end
-
-  describe "write single coil" do
-    it "should raise error if address of coil is mismatch" do
-      request = "\x5\x0\x8\xff\x0"
-      response = "\x5\x0\x9\xff\x0"
-      mock_query!(request, response)
-
-      lambda{ @slave.write_coil(8,true) }.should raise_response_mismatch(
-        "Address is mismatch (expected 8, got 9)",
-        request, response)
-    end
-
-    it "should raise error if value of coil is mismatch" do
-      request = "\x5\x0\x8\xff\x0"
-      response = "\x5\x0\x8\x0\x0"
-      mock_query!(request, response)
-
-      lambda{ @slave.write_coil(8,true) }.should raise_response_mismatch(
-        "Value is mismatch (expected 0xff00, got 0x0)",
-        request, response)
-    end
-  end
-
-  describe "write single register" do
-    it "should raise error if address of register is mismatch" do
-      request = "\x6\x0\x8\xa\xb"
-      response = "\x6\x0\x9\xa\xb"
-      mock_query!(request, response)
-
-      lambda{ @slave.write_single_register(8,0x0a0b) }.should raise_response_mismatch(
-        "Address is mismatch (expected 8, got 9)",
-        request, response)
-    end
-
-    it "should raise error if value of register is mismatch" do
-      request = "\x6\x0\x8\xa\xb"
-      response = "\x6\x0\x8\x9\xb"
-      mock_query!(request, response)
-
-      lambda{ @slave.write_single_register(8,0x0a0b) }.should raise_response_mismatch(
-        "Value is mismatch (expected 0xa0b, got 0x90b)",
-        request, response)
-    end
-  end
-
-  describe "write multiple coils" do
-    it "should raise error if address of first coil is mismatch" do
-      request = "\xf\x0\x13\x0\xa\2\xcd\x01"
-      response = "\xf\x0\x14\x0\xa"
-      mock_query!(request, response)
-
-      lambda{ @slave.write_coils(0x13,[1,0,1,1, 0,0,1,1, 1,0]) }.should raise_response_mismatch(
-        "Address is mismatch (expected 19, got 20)",
-        request, response)
-   end
-
-   it "should raise error if quantity of coils is mismatch" do
-      request = "\xf\x0\x13\x0\xa\2\xcd\x01"
-      response = "\xf\x0\x13\x0\x9"
-      mock_query!(request, response)
-
-      lambda{ @slave.write_coils(0x13,[1,0,1,1, 0,0,1,1, 1,0]) }.should raise_response_mismatch(
-        "Quantity is mismatch (expected 10, got 9)",
-        request, response)
-    end
-  end
-
-  describe "write multiple registers" do
-    it "should raise error if address of first register is mismatch" do
-      request = "\x10\x0\x1\x0\x2\x4\x0\xa\x1\x2"
-      response = "\x10\x0\x2\x0\x2"
-      mock_query!(request, response)
-
-      lambda{ @slave.write_holding_registers(0x1,[0xa,0x102]) }.should raise_response_mismatch(
-        "Address is mismatch (expected 1, got 2)",
-        request, response)
-   end
-
-   it "should raise error if quantity of registers is mismatch" do
-      request = "\x10\x0\x1\x0\x2\x4\x0\xa\x1\x2"
-      response = "\x10\x0\x2\x0\x1"
-      mock_query!(request, response)
-
-      lambda{ @slave.write_holding_registers(0x1,[0xa,0x102]) }.should raise_response_mismatch(
-        "Quantity is mismatch (expected 2, got 1)",
-        request, response)
-    end
-  end
-
-
-  private
-  def mock_query!(request, response)
-    @slave.should_receive(:send_pdu).with(request)
-    @slave.should_receive(:read_pdu).and_return(response)
-  end
-end

data/spec/rtu_client_spec.rb

@@ -1,86 +0,0 @@
-# -*- coding: ascii
-require 'rmodbus'
-
-describe ModBus::RTUClient do
-  before do 
-    @sp = double('Serial port')
-
-    SerialPort.should_receive(:new).with("/dev/port1", 9600, 8, 1, 0).and_return(@sp)    
-    SerialPort.stub(:public_method_defined?).with(:flush_input).and_return(true)
-
-    @sp.stub(:read_timeout=)
-    @sp.stub(:class).and_return(SerialPort)
-    @sp.should_receive(:flow_control=).with(SerialPort::NONE)
-    @sp.stub(:flush_input)
-
-    @cl = ModBus::RTUClient.new("/dev/port1", 9600, :data_bits => 8, :stop_bits => 1, :parity => SerialPort::NONE)
-    @slave = @cl.with_slave(1)
-    @slave.read_retries = 1
-  end
-
-  it "should ignore frame with other UID" do
-    request = "\x10\x0\x1\x0\x1\x2\xff\xff" 
-    @sp.should_receive(:write).with("\1#{request}\xA6\x31")
-    @sp.should_receive(:read).with(2).and_return("\x2\x10")
-    @sp.should_receive(:read).with(6).and_return("\x0\x1\x0\x1\x1C\x08")
-    lambda {@slave.query(request)}.should raise_error(ModBus::Errors::ModBusTimeout)
-  end
-
-  it "should ignored frame with incorrect CRC" do
-    request = "\x10\x0\x1\x0\x1\x2\xff\xff" 
-    @sp.should_receive(:write).with("\1#{request}\xA6\x31")
-    @sp.should_receive(:read).with(2).and_return("\x2\x10")
-    @sp.should_receive(:read).with(6).and_return("\x0\x1\x0\x1\x1C\x08")
-    lambda {@slave.query(request)}.should raise_error(ModBus::Errors::ModBusTimeout)
-  end
-  
-  it "should return value of registers"do
-    request = stab_valid_request
-    @slave.query(request).should == "\xff\xff"
-  end
-
-  it 'should sugar connect method' do
-    port, baud = "/dev/port1", 4800
-    SerialPort.should_receive(:new).with(port, baud, 8, 1, SerialPort::NONE).and_return(@sp)    
-    @sp.should_receive(:closed?).and_return(false)
-    @sp.should_receive(:close)
-    @sp.should_receive(:flow_control=).with(SerialPort::NONE)
-    ModBus::RTUClient.connect(port, baud) do |cl|
-      cl.port.should == port
-      cl.baud.should == baud
-      cl.data_bits.should == 8
-      cl.stop_bits.should == 1
-      cl.parity.should == SerialPort::NONE
-    end
-  end
-
-  it 'should have closed? method' do
-    @sp.should_receive(:closed?).and_return(false)
-    @cl.closed?.should == false
-
-    @sp.should_receive(:closed?).and_return(false)
-    @sp.should_receive(:close)
-
-    @cl.close
-
-    @sp.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
-
-  def stab_valid_request
-    request = "\x3\x0\x1\x0\x1"
-    @sp.should_receive(:write).with("\1#{request}\xd5\xca")
-    @sp.should_receive(:read).with(2).and_return("\x1\x3")
-    @sp.should_receive(:read).with(1).and_return("\x2")
-    @sp.should_receive(:read).with(4).and_return("\xff\xff\xb9\xf4")
-
-    request
-  end
-end
-