rmodbus 1.0.0-java

data/spec/exception_spec.rb

@@ -0,0 +1,116 @@
+require 'rmodbus'
+
+include ModBus::Errors
+
+describe ModBus::TCPClient do
+  before(:all) do
+    @srv = ModBus::TCPServer.new(1502, 1)
+    @srv.coils = [0] * 8
+    @srv.discrete_inputs = [0] * 8
+    @srv.holding_registers = [0] * 8
+    @srv.input_registers = [0] * 8
+    @srv.start
+
+    @cl = TCPClient.new('127.0.0.1', 1502)
+    @slave = @cl.with_slave(1)
+  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(IllegalDataAddress)
+  end
+
+  it "should raise exception if too many data" do
+   lambda { @slave.read_coils(0, 0x07D1) }.should raise_error(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(IllegalDataAddress)
+  end
+
+  it "should raise exception if too many data" do
+   lambda { @slave.read_discrete_inputs(0, 0x07D1) }.should raise_error(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(IllegalDataAddress)
+  end
+
+
+  it "should raise exception if too many data" do
+   lambda { @slave.read_holding_registers(0, 0x007E) }.should raise_error(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(IllegalDataAddress)
+  end
+
+  it "should raise exception if too many data" do
+   lambda { @slave.read_input_registers(0, 0x007E) }.should raise_error(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(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(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(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(IllegalDataAddress)
+  end
+
+  after(:all) do
+    @cl.close unless @cl.closed?
+    @srv.stop
+  end
+
+end

data/spec/ext_spec.rb

@@ -0,0 +1,46 @@
+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" 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 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

@@ -0,0 +1,65 @@
+require 'rmodbus'
+include ModBus
+
+describe TCPClient  do
+  before(:each) do
+    @uid = 1
+    @sock = mock("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('')
+
+    @slave = TCPClient.new('127.0.0.1', 1502).with_slave(@uid)
+  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)
+    @slave.debug = true
+    $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
+    request, response = "\x3\x0\x6b\x0\x3", "\x3\x6\x2\x2b\x0\x0\x0\x64"
+    mock_query(request,response)
+    @slave.query(request)
+  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
+
+unless RUBY_PLATFORM == "java"
+  describe RTUClient do
+    before do 
+      @sp = mock('Serial port')
+      SerialPort.should_receive(:new).with("/dev/port1", 9600, 7, 2, SerialPort::ODD).and_return(@sp)    
+      
+      @sp.stub!(:read_timeout=)
+      
+      @slave = 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(: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
+end

data/spec/proxy_spec.rb

@@ -0,0 +1,73 @@
+require 'rmodbus'
+
+describe Array do
+  before do
+    @slave = mock('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

@@ -0,0 +1,91 @@
+require 'rmodbus'
+include ModBus
+
+#Use public wrap method
+class Client
+  include 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 = 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("\xff\x0\x1\x0\x2").should raise_error {
+      ModBus::Errors::IllegalFunction
+    }
+  end
+
+  def make_resp(msg)
+    "\x1" + msg + "\x2\x2" # slave + msg + mock_crc
+  end
+end
+

data/spec/rtu_client_spec.rb

@@ -0,0 +1,74 @@
+require 'rmodbus'
+include ModBus
+
+describe RTUClient do
+  before do 
+    @sp = mock('Serial port')
+    SerialPort.should_receive(:new).with("/dev/port1", 9600, 8, 1, 0).and_return(@sp)    
+    @sp.stub!(:read_timeout=)
+    @sp.stub!(:read)
+
+    @cl = RTUClient.new("/dev/port1", 9600, :data_bits => 8, :stop_bits => 1, :parity => SerialPort::NONE)
+    @slave = @cl.with_slave(1)
+    @slave.read_retries = 0
+  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 = "\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")
+    @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)
+    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
+end
+

data/spec/rtu_server_spec.rb

@@ -0,0 +1,29 @@
+require 'rmodbus'
+include ModBus
+
+describe RTUServer do
+  before do
+    @sp = mock "SerialPort"
+    SerialPort.should_receive(:new).with('/dev/ttyS0', 4800, 7, 2, SerialPort::NONE).and_return(@sp)
+    @sp.stub!(:read_timeout=)
+
+    @server = RTUServer.new('/dev/ttyS0', 4800, 1, :data_bits => 7, :stop_bits => 2)
+    @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]
+  end
+
+  it "should be valid initialized " do
+    @server.coils.should == [1,0,1,1]
+    @server.discrete_inputs.should == [1,1,0,0]
+    @server.holding_registers.should == [1,2,3,4]
+    @server.input_registers.should == [1,2,3,4]
+
+    @server.port.should == '/dev/ttyS0'
+    @server.baud.should == 4800
+    @server.data_bits.should == 7
+    @server.stop_bits.should == 2
+    @server.parity.should == SerialPort::NONE
+  end
+end

data/spec/rtu_via_tcp_client_spec.rb

@@ -0,0 +1,78 @@
+require 'rmodbus'
+include ModBus
+
+describe RTUViaTCPClient do
+  describe "method 'query'" do    
+    before do 
+      @sock = mock('Socked')
+      TCPSocket.should_receive(:new).with("127.0.0.1", 10002).and_return(@sock)    
+      @sock.stub!(:read_timeout=)
+      @sock.stub!(:read)
+      
+      @cl = RTUViaTCPClient.new("127.0.0.1")
+      @slave = @cl.with_slave(1)
+      @slave.read_retries = 0
+    end
+    
+    it "should ignore frame with other UID" do
+      request = "\x10\x0\x1\x0\x1\x2\xff\xff" 
+      @sock.should_receive(:write).with("\1#{request}\xA6\x31")
+      @sock.should_receive(:read).with(2).and_return("\x2\x10")
+      @sock.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" 
+      @sock.should_receive(:write).with("\1#{request}\xA6\x31")
+      @sock.should_receive(:read).with(2).and_return("\x2\x10")
+      @sock.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 = "\x3\x0\x1\x0\x1"
+      @sock.should_receive(:write).with("\1#{request}\xd5\xca")
+      @sock.should_receive(:read).with(2).and_return("\x1\x3")
+      @sock.should_receive(:read).with(1).and_return("\x2")
+      @sock.should_receive(:read).with(4).and_return("\xff\xff\xb9\xf4")
+      @slave.query(request).should == "\xff\xff"
+    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)
+      RTUViaTCPClient.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
+    timeout(0.5) do
+      lambda { RTUViaTCPClient.new('81.123.231.11', 1999, :connect_timeout => 0.1) }.should raise_error(ModBusTimeout)
+    end
+  end
+end

data/spec/slave_spec.rb

@@ -0,0 +1,55 @@
+require 'rmodbus'
+include ModBus
+
+describe Slave do
+  before do
+    @slave = Client.new.with_slave(1)
+
+    @slave.stub!(:query).and_return('')
+  end
+
+  it "should support function 'read coils'" do
+    @slave.should_receive(:query).with("\x1\x0\x13\x0\x13").and_return("\xcd\x6b\x5")    
+    @slave.read_coils(0x13,0x13).should == [1,0,1,1, 0,0,1,1, 1,1,0,1, 0,1,1,0,  1,0,1]
+  end
+
+  it "should support function 'read discrete inputs'" do
+    @slave.should_receive(:query).with("\x2\x0\xc4\x0\x16").and_return("\xac\xdb\x35")    
+    @slave.read_discrete_inputs(0xc4,0x16).should == [0,0,1,1, 0,1,0,1, 1,1,0,1, 1,0,1,1, 1,0,1,0, 1,1]
+  end
+
+  it "should support function 'read holding registers'" do
+    @slave.should_receive(:query).with("\x3\x0\x6b\x0\x3").and_return("\x2\x2b\x0\x0\x0\x64")    
+    @slave.read_holding_registers(0x6b,0x3).should == [0x022b, 0x0000, 0x0064]
+  end
+
+  it "should support function 'read input registers'" do
+    @slave.should_receive(:query).with("\x4\x0\x8\x0\x1").and_return("\x0\xa")    
+    @slave.read_input_registers(0x8,0x1).should == [0x000a]
+  end
+
+  it "should support function 'write single coil'" do
+    @slave.should_receive(:query).with("\x5\x0\xac\xff\x0").and_return("\xac\xff\x00")    
+    @slave.write_single_coil(0xac,0x1).should == @slave
+  end
+
+  it "should support function 'write single register'" do
+    @slave.should_receive(:query).with("\x6\x0\x1\x0\x3").and_return("\x1\x0\x3")    
+    @slave.write_single_register(0x1,0x3).should == @slave
+  end
+
+  it "should support function 'write multiple coils'" do
+    @slave.should_receive(:query).with("\xf\x0\x13\x0\xa\x2\xcd\x1").and_return("\x13\x0\xa")    
+    @slave.write_multiple_coils(0x13,[1,0,1,1, 0,0,1,1, 1,0]).should == @slave
+  end
+
+  it "should support function 'write multiple registers'" do
+    @slave.should_receive(:query).with("\x10\x0\x1\x0\x3\x6\x0\xa\x1\x2\xf\xf").and_return("\x1\x0\x3")    
+    @slave.write_multiple_registers(0x1,[0x000a,0x0102, 0xf0f]).should == @slave
+  end
+
+  it "should support function 'mask write register'" do
+    @slave.should_receive(:query).with("\x16\x0\x4\x0\xf2\x0\2").and_return("\x4\x0\xf2\x0\x2")
+    @slave.mask_write_register(0x4, 0xf2, 0x2).should == @slave
+  end
+end