denko 0.13.2 → 0.13.3

data/test/behaviors/listener_test.rb

@@ -28,13 +28,13 @@ class ListenerTest < Minitest::Test
   end
 
   def test_call_stop_before_listening
-    mock = MiniTest::Mock.new.expect :call, nil
+    mock = Minitest::Mock.new.expect :call, nil
     part.stub(:stop, mock) { part.listen }
     mock.verify
   end
 
   def test_call__listen
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect :call, nil, [nil]
     mock.expect :call, nil, [32]
     part.stub(:_listen, mock) do
@@ -45,7 +45,7 @@ class ListenerTest < Minitest::Test
   end
 
   def test_call__stop_listener
-    mock = MiniTest::Mock.new.expect :call, nil
+    mock = Minitest::Mock.new.expect :call, nil
     part.stub(:_stop_listener, mock) { part.stop }
     mock.verify
   end

data/test/behaviors/poller_test.rb

@@ -37,13 +37,13 @@ class PollerTest < Minitest::Test
   end
 
   def test_call_stop_before_polling
-    mock = MiniTest::Mock.new.expect :call, nil
+    mock = Minitest::Mock.new.expect :call, nil
     part.stub(:stop, mock) { part.poll(1) }
     mock.verify
   end
 
   def test_uses_threaded_loop
-    mock = MiniTest::Mock.new.expect :call, nil
+    mock = Minitest::Mock.new.expect :call, nil
     part.stub(:threaded_loop, mock) { part.poll(1) }
     mock.verify
   end
@@ -57,7 +57,7 @@ class PollerTest < Minitest::Test
   end
 
   def test_stop_kills_thread
-    mock = MiniTest::Mock.new.expect :call, nil
+    mock = Minitest::Mock.new.expect :call, nil
     part.stub(:stop_thread, mock) { part.stop }
     mock.verify
   end

data/test/behaviors/reader_test.rb

@@ -37,7 +37,7 @@ class ReaderTest < Minitest::Test
   end
 
   def test_read_once
-    mock = MiniTest::Mock.new.expect :call, nil
+    mock = Minitest::Mock.new.expect :call, nil
     inject(1)
     
     part.stub(:_read, mock) do
@@ -53,20 +53,20 @@ class ReaderTest < Minitest::Test
   
   def test_read_using_with_lambda
     inject(1)
-    reader = MiniTest::Mock.new.expect :call, nil
+    reader = Minitest::Mock.new.expect :call, nil
     part.read_using -> { reader.call }
     reader.verify
   end
 
   def test_read_using_with_method_and_args
     inject(1)
-    reader = MiniTest::Mock.new.expect :call, nil, [10, 20], test_arg: 2
+    reader = Minitest::Mock.new.expect :call, nil, [10, 20], test_arg: 2
     part.read_using reader, 10, 20, test_arg: 2
     reader.verify
   end
 
   def test_add_run_remove_callback
-    cb = MiniTest::Mock.new.expect :call, nil
+    cb = Minitest::Mock.new.expect :call, nil
     inject(1)
     part.read { cb.call }
     assert_nil part.callbacks[:read]

data/test/behaviors/subcomponents_test.rb

@@ -65,7 +65,7 @@ class SubcomponentsTest < Minitest::Test
     pinless = PinlessComponentMock.new
     board.add_component(pinless)
 
-    mock = MiniTest::Mock.new.expect(:call, nil)
+    mock = Minitest::Mock.new.expect(:call, nil)
     pinless.stub(:stop, mock) do
       board.remove_component(pinless)
     end

data/test/behaviors/threaded_test.rb

@@ -24,19 +24,19 @@ class ThreadedTest < Minitest::Test
   end
 
   def test_threaded_stops_threads
-    mock = MiniTest::Mock.new.expect :call, nil
+    mock = Minitest::Mock.new.expect :call, nil
     part.stub(:stop_thread, mock) { part.threaded {} }
     mock.verify
   end
 
   def test_threaded_enables_interrupts
-    mock = MiniTest::Mock.new.expect :call, nil
+    mock = Minitest::Mock.new.expect :call, nil
     part.stub(:enable_interrupts, mock) { part.threaded {} }
     mock.verify
   end
 
   def test_threaded_calls_block_given
-    mock = MiniTest::Mock.new.expect :call, nil
+    mock = Minitest::Mock.new.expect :call, nil
     part.threaded { mock.call }
     sleep 0.1 # Should find a better way to do this.
     mock.verify
@@ -49,7 +49,7 @@ class ThreadedTest < Minitest::Test
   end
 
   def test_threaded_loop_calls_block_repeatedly
-    mock = MiniTest::Mock.new.expect(:call, nil).expect(:call, nil)
+    mock = Minitest::Mock.new.expect(:call, nil).expect(:call, nil)
     part.stub(:foo, mock) do
       part.threaded_loop do
         part.foo
@@ -61,7 +61,7 @@ class ThreadedTest < Minitest::Test
   end
 
   def test_stop_thread_kills_thread
-    mock = MiniTest::Mock.new.expect(:kill, nil)
+    mock = Minitest::Mock.new.expect(:kill, nil)
     part.instance_variable_set(:@thread, mock)
     part.stop_thread
     mock.verify
@@ -81,7 +81,7 @@ class ThreadedTest < Minitest::Test
   end
 
   def test_original_method_called_when_interrupts_enabled
-    mock = MiniTest::Mock.new.expect(:call, nil, ["denko"])
+    mock = Minitest::Mock.new.expect(:call, nil, ["denko"])
     part.stub(:foo, mock) do
       part.enable_interrupts
       part.foo("denko")
@@ -91,7 +91,7 @@ class ThreadedTest < Minitest::Test
 
   def test_interrupt_stops_thread
     part.enable_interrupts
-    mock = MiniTest::Mock.new.expect :call, nil
+    mock = Minitest::Mock.new.expect :call, nil
     part.stub(:stop_thread, mock) { part. foo }
     mock.verify
   end

data/test/board/board_test.rb

@@ -15,7 +15,7 @@ class BoardTest < Minitest::Test
 
   def test_starts_observing_connection
     io = ConnectionMock.new
-    mock = MiniTest::Mock.new.expect(:call, nil, [Denko::Board])
+    mock = Minitest::Mock.new.expect(:call, nil, [Denko::Board])
     io.stub(:add_observer, mock) do
       Denko::Board.new(io)
     end
@@ -23,7 +23,7 @@ class BoardTest < Minitest::Test
   end
 
   def test_calls_handshake_on_connection
-    mock = MiniTest::Mock.new.expect(:call, Constants::ACK)
+    mock = Minitest::Mock.new.expect(:call, Constants::ACK)
     connection.stub(:handshake, mock) do
       Denko::Board.new(connection)
     end
@@ -49,7 +49,7 @@ class BoardTest < Minitest::Test
     assert_equal 1023, board.analog_read_high
     assert_equal 10,   board.analog_read_resolution
     
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect(:call, nil, [Denko::Message.encode(command:96, value:12)])
     mock.expect(:call, nil, [Denko::Message.encode(command:97, value:12)])
     board.stub(:write, mock) do
@@ -66,7 +66,7 @@ class BoardTest < Minitest::Test
   end
   
   def test_eeprom
-    mock = MiniTest::Mock.new.expect(:call, "test eeprom", [], board: board)
+    mock = Minitest::Mock.new.expect(:call, "test eeprom", [], board: board)
     Denko::EEPROM::BuiltIn.stub(:new, mock) do
       board.eeprom
     end
@@ -75,7 +75,7 @@ class BoardTest < Minitest::Test
 
   def test_write
     board
-    mock = MiniTest::Mock.new.expect(:call, nil, ["message"])
+    mock = Minitest::Mock.new.expect(:call, nil, ["message"])
     connection.stub(:write, mock) do
       board.write("message")
     end
@@ -83,16 +83,16 @@ class BoardTest < Minitest::Test
   end
 
   def test_update_passes_messages_to_correct_components
-    mock1 = MiniTest::Mock.new.expect(:update, nil, ["data"])
+    mock1 = Minitest::Mock.new.expect(:update, nil, ["data"])
     3.times { mock1.expect(:pin, 1) }
     
     # Make sure lines are split only on the first colon.
     # Tests for string based pine names too.
-    mock2 = MiniTest::Mock.new.expect(:update, nil, ["with:colon"])
+    mock2 = Minitest::Mock.new.expect(:update, nil, ["with:colon"])
     3.times { mock2.expect(:pin, 14) }
     
     # Special EEPROM mock.
-    mock3 = MiniTest::Mock.new.expect(:update, nil, ["bytes"])
+    mock3 = Minitest::Mock.new.expect(:update, nil, ["bytes"])
     3.times { mock3.expect(:pin, 254) }
      
     board.add_component(mock1)

data/test/board/core_test.rb

@@ -12,7 +12,7 @@ class BoardCoreTest < Minitest::Test
   end
 
   def test_set_pin_mode
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect(:call, nil, [Denko::Message.encode(command: 0, pin: 1, value: 0b000)])
     mock.expect(:call, nil, [Denko::Message.encode(command: 0, pin: 1, value: 0b010)])
     mock.expect(:call, nil, [Denko::Message.encode(command: 0, pin: 1, value: 0b100)])
@@ -36,7 +36,7 @@ class BoardCoreTest < Minitest::Test
   end
 
   def test_digital_write
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect(:call, nil, [Denko::Message.encode(command: 1, pin: 1, value: board.low)])
     mock.expect(:call, nil, [Denko::Message.encode(command: 1, pin: 1, value: board.high)])
 
@@ -50,7 +50,7 @@ class BoardCoreTest < Minitest::Test
   end
 
   def test_digital_read
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect(:call, nil, [Denko::Message.encode(command: 2, pin: 1)])
 
     board.stub(:write, mock) do
@@ -60,7 +60,7 @@ class BoardCoreTest < Minitest::Test
   end
 
   def test_pwm_write
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect(:call, nil, [Denko::Message.encode(command: 3, pin: 1, value: board.low)])
     mock.expect(:call, nil, [Denko::Message.encode(command: 3, pin: 1, value: board.pwm_high)])
     mock.expect(:call, nil, [Denko::Message.encode(command: 3, pin: 1, value: 128)])
@@ -76,7 +76,7 @@ class BoardCoreTest < Minitest::Test
   end
   
   def test_dac_write
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect(:call, nil, [Denko::Message.encode(command: 4, pin: 1, value: board.low)])
     mock.expect(:call, nil, [Denko::Message.encode(command: 4, pin: 1, value: board.dac_high)])
     mock.expect(:call, nil, [Denko::Message.encode(command: 4, pin: 1, value: 128)])
@@ -92,7 +92,7 @@ class BoardCoreTest < Minitest::Test
   end
 
   def test_analog_read
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect(:call, nil, [Denko::Message.encode(command: 5, pin: 1)])
 
     board.stub(:write, mock) do
@@ -102,7 +102,7 @@ class BoardCoreTest < Minitest::Test
   end
 
   def test_set_listener
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
 
     # \x00\x02 corresponds to the default digital divider of 4 (2^2).
     # \x00\x04 corresponds to the default analog divider of 16 (2^4).
@@ -124,7 +124,7 @@ class BoardCoreTest < Minitest::Test
   end
 
   def test_digital_listen
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect(:call, nil, [1, :on], mode: :digital, divider: 4)
 
     board.stub(:set_listener, mock) do
@@ -133,7 +133,7 @@ class BoardCoreTest < Minitest::Test
   end
 
   def test_analog_listen
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect(:call, nil, [1, :on], mode: :analog, divider: 16)
 
     board.stub(:set_listener, mock) do
@@ -142,7 +142,7 @@ class BoardCoreTest < Minitest::Test
   end
 
   def test_stop_listener
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect(:call, nil, [1, :off])
 
     board.stub(:set_listener, mock) do
@@ -151,7 +151,7 @@ class BoardCoreTest < Minitest::Test
   end
 
   def test_analog_resolution
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect(:call, nil, [Denko::Message.encode(command: 96, value: 10)])
     mock.expect(:call, nil, [Denko::Message.encode(command: 97, value: 10)])
 
@@ -170,7 +170,7 @@ class BoardCoreTest < Minitest::Test
   def micro_delay   
     aux = pack(:uint16, [1000])
     message = Denko::Message.encode command: 99, aux_message: aux
-    mock = MiniTest::Mock.new.expect :call, nil, [message]
+    mock = Minitest::Mock.new.expect :call, nil, [message]
     
     board.stub(:write, mock) do
       board.micro_delay(1000)

data/test/board/eeprom_test.rb

@@ -12,7 +12,7 @@ class BoardEEPROMTest < Minitest::Test
   end
 
   def test_eeprom_read
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect :call, nil, [(Denko::Message.encode command: 7, value: 16, aux_message: pack(:uint16, 15))]
 
     board.stub(:write, mock) do
@@ -23,7 +23,7 @@ class BoardEEPROMTest < Minitest::Test
 
   def test_eeprom_write
     data = (1..16).to_a
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect :call, nil, [(Denko::Message.encode command: 8, value: data.length, aux_message: pack(:uint16, 15) + pack(:uint8, data))]
 
     board.stub(:write, mock) do

data/test/board/i2c_test.rb

@@ -15,7 +15,7 @@ class APII2CTest < Minitest::Test
     board
     message = Denko::Message.encode command: 33
     
-    mock = MiniTest::Mock.new.expect :call, nil, [message]
+    mock = Minitest::Mock.new.expect :call, nil, [message]
     connection.stub(:write, mock) do
       board.i2c_search
     end
@@ -32,7 +32,7 @@ class APII2CTest < Minitest::Test
     # Repeated start
     message2 = Denko::Message.encode command: 34, pin: address | (0 << 7), value: 4, aux_message: aux
 
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect :call, nil, [message1]
     mock.expect :call, nil, [message2]
     
@@ -56,7 +56,7 @@ class APII2CTest < Minitest::Test
     # Repeated start
     message2 = Denko::Message.encode command: 35, pin: 0x30 | (0 << 7), value: 4, aux_message: aux
 
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect :call, nil, [message1]
     mock.expect :call, nil, [message2]
     
@@ -72,7 +72,7 @@ class APII2CTest < Minitest::Test
     aux = pack(:uint8, 0x00) + pack(:uint8, [0])
     message = Denko::Message.encode command: 35, pin: 0x30 | (1 << 7), value: 4, aux_message: aux
 
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect :call, nil, [message]
     
     connection.stub(:write, mock) do
@@ -97,7 +97,7 @@ class APII2CTest < Minitest::Test
       messages << Denko::Message.encode(command: 34, pin: 0x30 | (1 << 7), value: 4, aux_message: pack(:uint8, code) + pack(:uint8, data))
     end
 
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     messages.each do |message|
       mock.expect :call, nil, [message]
     end

data/test/board/infrared_test.rb

@@ -16,7 +16,7 @@ class APIInfraredTest < Minitest::Test
     aux = pack(:uint8, 4) + pack(:uint16, [255,0,255,0])
     message = Denko::Message.encode command: 16, pin: 8, value: 38, aux_message: aux
     
-    mock = MiniTest::Mock.new.expect :call, nil, [message]
+    mock = Minitest::Mock.new.expect :call, nil, [message]
     connection.stub(:write, mock) do
       board.infrared_emit 8, 38, [255,0,255,0]
     end

data/test/board/message_test.rb

@@ -25,7 +25,7 @@ class MessageTest < Minitest::Test
   end
 
   def test_validates_aux_message_length
-    too_big_message = Array.new(529) { "a" }.join 
+    too_big_message = Array.new(785) { "a" }.join
     assert_raises(ArgumentError) { Denko::Message.encode command: 0, value: 0, aux_message: too_big_message }
   end
 

data/test/board/one_wire_test.rb

@@ -15,7 +15,7 @@ class APIOneWireTest < Minitest::Test
     board
     message = Denko::Message.encode command: 41, pin: 1, value: 255
     
-    mock = MiniTest::Mock.new.expect :call, nil, [message]
+    mock = Minitest::Mock.new.expect :call, nil, [message]
     connection.stub(:write, mock) do
       board.one_wire_reset(1, 255)
     end
@@ -26,7 +26,7 @@ class APIOneWireTest < Minitest::Test
     board
     message = Denko::Message.encode command: 42, pin: 1, aux_message: pack(:uint64, 128, max:8)
     
-    mock = MiniTest::Mock.new.expect :call, nil, [message]
+    mock = Minitest::Mock.new.expect :call, nil, [message]
     connection.stub(:write, mock) do
       board.one_wire_search(1, 128)
     end
@@ -40,7 +40,7 @@ class APIOneWireTest < Minitest::Test
     message1 = Denko::Message.encode command: 43, pin: 1, value: 0b10000000 | 3, aux_message: pack(:uint8, [1,2,3])
     message2 = Denko::Message.encode command: 43, pin: 1, value: 4, aux_message: pack(:uint8, [1,2,3,4])
     
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect :call, nil, [message1]
     mock.expect :call, nil, [message2]
     connection.stub(:write, mock) do
@@ -60,7 +60,7 @@ class APIOneWireTest < Minitest::Test
     board
     message = Denko::Message.encode command: 44, pin: 1, value: 9
         
-    mock = MiniTest::Mock.new.expect :call, nil, [message]
+    mock = Minitest::Mock.new.expect :call, nil, [message]
     connection.stub(:write, mock) do
       board.one_wire_read(1, 9)
     end

data/test/board/pulse_test.rb

@@ -13,7 +13,7 @@ class BoardPulseTest < Minitest::Test
 
   def test_pulse_read
     # Default settings
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     aux = pack(:uint16, [0, 200]) << pack(:uint8, 100)
     message = Denko::Message.encode command: 9, pin: 4, value: 0b00, aux_message: aux
     
@@ -24,7 +24,7 @@ class BoardPulseTest < Minitest::Test
     mock.verify
     
     # Good options
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     aux = pack(:uint16, [1000, 200]) << pack(:uint8, 160)
     message1 = Denko::Message.encode command: 9, pin: 4, value: 0b01, aux_message: aux
     message2 = Denko::Message.encode command: 9, pin: 4, value: 0b11, aux_message: aux

data/test/board/servo_test.rb

@@ -12,7 +12,7 @@ class APIServoTest < Minitest::Test
   end
 
   def test_on_off
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     aux = pack :uint16, [544, 2400]
     mock.expect :call, nil, [Denko::Message.encode(command: 10, pin: 9, value: 1, aux_message: aux)]
     mock.expect :call, nil, [Denko::Message.encode(command: 10, pin: 9, value: 0, aux_message: aux)]
@@ -25,7 +25,7 @@ class APIServoTest < Minitest::Test
   end
 
   def test_min_max
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     aux = pack :uint16, [360, 2100]
     mock.expect :call, nil, [Denko::Message.encode(command: 10, pin: 9, value: 1, aux_message: aux)]
 
@@ -36,7 +36,7 @@ class APIServoTest < Minitest::Test
   end
   
   def test_write
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect :call, nil, [Denko::Message.encode(command: 11, pin: 9, aux_message: pack(:uint16, 180))]
 
     board.stub(:write, mock) do

data/test/board/spi_test.rb

@@ -64,7 +64,7 @@ class APISPITest < Minitest::Test
     bytes = [1,2,3,4]
     header = board.spi_header(bytes, 4, 8000000, 2, :lsbfirst)
     aux = header + pack(:uint8, bytes)
-    mock = MiniTest::Mock.new.expect  :call, nil,
+    mock = Minitest::Mock.new.expect  :call, nil,
                                       [Denko::Message.encode(command: 26, pin: 3, aux_message: aux)]
     
     board.stub(:write, mock) do
@@ -77,7 +77,7 @@ class APISPITest < Minitest::Test
   def test_spi_listen
     board
     header = board.spi_header([], 8, 1000000, 0, :lsbfirst)
-    mock = MiniTest::Mock.new.expect  :call, nil,
+    mock = Minitest::Mock.new.expect  :call, nil,
                                       [Denko::Message.encode(command: 27, pin: 3, aux_message: header)]
     
     board.stub(:write, mock) do
@@ -88,7 +88,7 @@ class APISPITest < Minitest::Test
   
   def test_spi_stop
     board
-    mock = MiniTest::Mock.new.expect :call, nil, [Denko::Message.encode(command: 28, pin: 3)]
+    mock = Minitest::Mock.new.expect :call, nil, [Denko::Message.encode(command: 28, pin: 3)]
     board.stub(:write, mock) do
       board.spi_stop(3)
     end

data/test/board/tone_test.rb

@@ -12,7 +12,7 @@ class APIToneTest < Minitest::Test
   end
 
   def test_tone
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     aux1 = pack(:uint16, 150) + pack(:uint16, 2000)
     aux2 = pack(:uint16, 300)
     
@@ -31,7 +31,7 @@ class APIToneTest < Minitest::Test
   end
 
   def test_no_tone
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect :call, nil, [Denko::Message.encode(command: 18, pin: 10)]
 
     board.stub(:write, mock) do

data/test/connection/serial_test.rb

@@ -18,7 +18,7 @@ class SerialConnectionTest < Minitest::Test
   end
   
   def test_connect_with_device_specified
-    mock = MiniTest::Mock.new.expect(:call, "SerialMock", ["/dev/ttyACM0", 9600])
+    mock = Minitest::Mock.new.expect(:call, "SerialMock", ["/dev/ttyACM0", 9600])
     ::Serial.stub(:new, mock) do
       connection = Denko::Connection::Serial.new(device: "/dev/ttyACM0", baud: 9600)
       assert_equal "SerialMock", suppress_output { connection.send(:io) }
@@ -34,7 +34,7 @@ class SerialConnectionTest < Minitest::Test
 
   def test_connect_on_unix
     connection.stub(:tty_devices, ['/dev/ttyACM0', '/dev/tty.usbmodem1']) do
-      mock =  MiniTest::Mock.new
+      mock =  Minitest::Mock.new
       # Raise error for first device
       mock.expect(:call, nil) { raise RubySerial::Error }
       mock.expect :call, "serial-obj", ['/dev/tty.usbmodem1', Denko::Connection::Serial::BAUD]
@@ -50,7 +50,7 @@ class SerialConnectionTest < Minitest::Test
     # Simulate being on Windows
     Constants.redefine(:RUBY_PLATFORM, "mswin", :on => Object)
 
-    mock =  MiniTest::Mock.new
+    mock =  Minitest::Mock.new
     # Raise error for COM1
     mock.expect(:call, nil) { raise RubySerial::Error }
     mock.expect :call, "serial-obj", ["COM2", Denko::Connection::Serial::BAUD]
@@ -65,11 +65,11 @@ class SerialConnectionTest < Minitest::Test
   end
 
   def test_io_reset
-    flush_mock = MiniTest::Mock.new.expect :call, true
-    r_stop_mock = MiniTest::Mock.new.expect :call, true
-    r_start_mock = MiniTest::Mock.new.expect :call, true
-    w_stop_mock = MiniTest::Mock.new.expect :call, true
-    w_start_mock = MiniTest::Mock.new.expect :call, true
+    flush_mock = Minitest::Mock.new.expect :call, true
+    r_stop_mock = Minitest::Mock.new.expect :call, true
+    r_start_mock = Minitest::Mock.new.expect :call, true
+    w_stop_mock = Minitest::Mock.new.expect :call, true
+    w_start_mock = Minitest::Mock.new.expect :call, true
 
     connection.stub(:flush_read, flush_mock) do
       connection.stub(:stop_read, r_stop_mock) do
@@ -98,7 +98,7 @@ class SerialConnectionTest < Minitest::Test
   end
   
   def test_parse
-    mock = MiniTest::Mock.new.expect :call, nil, ['02:00:00']
+    mock = Minitest::Mock.new.expect :call, nil, ['02:00:00']
     connection.stub(:changed, true) do
       connection.stub(:notify_observers, mock) do
         connection.send(:parse, '02:00:00')
@@ -132,7 +132,7 @@ class SerialConnectionTest < Minitest::Test
     connection.write('message')
 
     # Message is written from buffer when we start the write thread.
-    mock = MiniTest::Mock.new.expect :call, nil, ['message']
+    mock = Minitest::Mock.new.expect :call, nil, ['message']
     connection.stub(:_write, mock) do
       # Start the write thread and wait for the buffer to empty.
       connection.send(:start_write)  
@@ -144,7 +144,7 @@ class SerialConnectionTest < Minitest::Test
   end
 
   def test_io_read_single_chars_until_newline_and_strips_it
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect :read, "line\n", [64]
     connection.stub(:io, mock) do
       assert_equal "line", connection.send(:read)
@@ -153,7 +153,7 @@ class SerialConnectionTest < Minitest::Test
   end
 
   def test_io_read_handles_escaped_newlines_and_backslashes
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect :read, "l1\\\nl2\\\\\n", [64]
     connection.stub(:io, mock) do
       assert_equal "l1\nl2\\", connection.send(:read)
@@ -162,7 +162,7 @@ class SerialConnectionTest < Minitest::Test
   end
 
   def test_io_read_returns_empty_string_if_just_newline
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect :read, "\n", [64]
     connection.stub(:io, mock) do
       assert_equal "", connection.send(:read)

data/test/digital_io/input_test.rb

@@ -10,7 +10,7 @@ class DigitalIOInputTest < Minitest::Test
   end
 
   def test_start_listening_immediately
-    mock = MiniTest::Mock.new.expect :call, nil, [14, 4]
+    mock = Minitest::Mock.new.expect :call, nil, [14, 4]
     board.stub(:digital_listen, mock) do
       part
     end
@@ -24,7 +24,7 @@ class DigitalIOInputTest < Minitest::Test
   end
 
   def test__read
-    mock = MiniTest::Mock.new.expect :call, nil, [14]
+    mock = Minitest::Mock.new.expect :call, nil, [14]
     board.stub(:digital_read, mock) do
       part._read
     end
@@ -33,7 +33,7 @@ class DigitalIOInputTest < Minitest::Test
 
   def test__listen
     part
-    mock = MiniTest::Mock.new
+    mock = Minitest::Mock.new
     mock.expect :call, nil, [14, 4]
     mock.expect :call, nil, [14, 32]
     board.stub(:digital_listen, mock) do
@@ -44,8 +44,8 @@ class DigitalIOInputTest < Minitest::Test
   end
 
   def test_on_low
-    low_cb  = MiniTest::Mock.new.expect :call, nil
-    high_cb = MiniTest::Mock.new
+    low_cb  = Minitest::Mock.new.expect :call, nil
+    high_cb = Minitest::Mock.new
     part.on_low { low_cb.call }
     part.on_high { high_cb.call }
     part.update(board.low)
@@ -54,8 +54,8 @@ class DigitalIOInputTest < Minitest::Test
   end
 
   def test_on_high
-    low_cb  = MiniTest::Mock.new
-    high_cb = MiniTest::Mock.new.expect :call, nil
+    low_cb  = Minitest::Mock.new
+    high_cb = Minitest::Mock.new.expect :call, nil
     part.on_low { low_cb.call }
     part.on_high { high_cb.call }
     part.update(board.high)