pi_driver 0.0.2 → 0.0.3

data/test/device/mcp23017_test_helper.rb

@@ -0,0 +1,13 @@
+require_relative '../test_helper'
+
+class MCP23017Test < TestCase
+  def setup
+    @clock_pin = PiDriver::Pin.new 1
+    @data_pin = PiDriver::Pin.new 2
+    @i2c_master = PiDriver::I2CMaster.new clock_pin: @clock_pin, data_pin: @data_pin
+    @mcp23017 = PiDriver::Device::MCP23017.new i2c_master: @i2c_master
+    @mcp23017.hardware_address.a0 = 1
+    @mcp23017.hardware_address.a1 = 1
+    @mcp23017.hardware_address.a2 = 1
+  end
+end

data/test/i2c_master/test_ack.rb

@@ -0,0 +1,26 @@
+require_relative '../i2c_master_test_helper'
+
+class I2CAckTest < I2CMasterTest
+  def test_ack
+    @sequence = sequence('ack')
+    expect_sequence_ack true
+
+    assert @i2c_master.ack
+  end
+
+  def test_nack
+    @sequence = sequence('nack')
+    expect_sequence_ack false
+
+    refute @i2c_master.ack
+  end
+
+  private
+
+  def expect_sequence_ack(success)
+    expect_data_pin_to_be_released
+    expect_clock_pin_to_be_released
+    @data_pin.expects(:clear?).with(nil).returns(success).in_sequence(@sequence)
+    expect_clock_pin_to_be_driven
+  end
+end

data/test/i2c_master/test_address.rb

@@ -0,0 +1,15 @@
+require_relative '../i2c_master_test_helper'
+
+class I2CAddressTest < I2CMasterTest
+  def test_prepare_address_for_write
+    address_byte = 0b1010101
+    prepared_address = PiDriver::I2CMaster.prepare_address_for_write address_byte
+    assert_equal 0b10101010, prepared_address
+  end
+
+  def test_prepare_address_for_read
+    address_byte = 0b1010101
+    prepared_address = PiDriver::I2CMaster.prepare_address_for_read address_byte
+    assert_equal 0b10101011, prepared_address
+  end
+end

data/test/i2c_master/test_alias.rb

@@ -0,0 +1,7 @@
+require_relative '../i2c_master_test_helper'
+
+class I2CAliasTest < I2CMasterTest
+  def test_start_aliases
+    assert_equal @i2c_master.method(:start), @i2c_master.method(:restart)
+  end
+end

data/test/i2c_master/test_clock_stretch.rb

@@ -0,0 +1,26 @@
+require_relative '../i2c_master_test_helper'
+
+class I2CClockStretchTest < I2CMasterTest
+  def test_clock_stretch
+    @sequence = sequence('clock stretch')
+    @clock_pin.expects(:input).with(nil).in_sequence(@sequence)
+    @clock_pin.expects(:set?).with(nil).returns(false).times(3).in_sequence(@sequence)
+    @clock_pin.expects(:set?).with(nil).returns(true).in_sequence(@sequence)
+
+    @i2c_master.send(:release_clock_pin)
+  end
+
+  def test_clock_stretch_timeout
+    @sequence = sequence('clock stretch timeout')
+    @clock_pin.expects(:input).with(nil).in_sequence(@sequence)
+    @clock_pin.expects(:set?).with(nil).returns(false).at_least_once.in_sequence(@sequence)
+
+    test_began_at = Time.now
+    @i2c_master.send(:release_clock_pin)
+    test_ended_at = Time.now
+    time_delta = test_ended_at - test_began_at
+    one_millisecond = 0.001
+    two_milliseconds = 0.002
+    assert time_delta > one_millisecond && time_delta < two_milliseconds
+  end
+end

data/test/i2c_master/test_read.rb

@@ -0,0 +1,27 @@
+require_relative '../i2c_master_test_helper'
+
+class I2CReadTest < I2CMasterTest
+  def test_read
+    @sequence = sequence('read')
+    expect_data_pin_to_be_released
+    expect_bit_read 1
+    expect_bit_read 0
+    expect_bit_read 0
+    expect_bit_read 0
+    expect_bit_read 1
+    expect_bit_read 1
+    expect_bit_read 0
+    expect_bit_read 1
+
+    byte = @i2c_master.read
+    assert_equal 0b10001101, byte
+  end
+
+  private
+
+  def expect_bit_read(value)
+    expect_clock_pin_to_be_released
+    @data_pin.expects(:value).with(nil).returns(value).in_sequence(@sequence)
+    expect_clock_pin_to_be_driven
+  end
+end

data/test/i2c_master/test_speed.rb

@@ -0,0 +1,11 @@
+require_relative '../i2c_master_test_helper'
+
+class I2CSpeedTest < I2CMasterTest
+  def test_speed
+    test_began_at = Time.now
+    @i2c_master.send(:release_clock_pin)
+    test_ended_at = Time.now
+    frequency = (1.0 / (test_ended_at - test_began_at))
+    assert frequency < 100_000
+  end
+end

data/test/i2c_master/test_start.rb

@@ -0,0 +1,11 @@
+require_relative '../i2c_master_test_helper'
+
+class I2CStartTest < I2CMasterTest
+  def test_start
+    @sequence = sequence('start')
+    expect_data_pin_to_be_driven
+    expect_clock_pin_to_be_driven
+
+    @i2c_master.start
+  end
+end

data/test/i2c_master/test_stop.rb

@@ -0,0 +1,24 @@
+require_relative '../i2c_master_test_helper'
+
+class I2CStopTest < I2CMasterTest
+  def test_new_i2c_stop
+    @sequence = sequence('stop')
+    expect_sequence_stop
+    
+    PiDriver::I2CMaster.new clock_pin: @clock_pin, data_pin: @data_pin
+  end
+
+  def test_stop
+    @sequence = sequence('stop')
+    expect_sequence_stop
+
+    @i2c_master.stop
+  end
+
+  private
+
+  def expect_sequence_stop
+    expect_clock_pin_to_be_released
+    expect_data_pin_to_be_released
+  end
+end

data/test/i2c_master/test_write.rb

@@ -0,0 +1,29 @@
+require_relative '../i2c_master_test_helper'
+
+class I2CWriteTest < I2CMasterTest
+  def test_write
+    @sequence = sequence('write')
+    expect_bit_write 1
+    expect_bit_write 0
+    expect_bit_write 1
+    expect_bit_write 1
+    expect_bit_write 0
+    expect_bit_write 0
+    expect_bit_write 0
+    expect_bit_write 1
+
+    @i2c_master.write(0b10110001)
+  end
+
+  private
+
+  def expect_bit_write(value)
+    if value == 0
+      expect_data_pin_to_be_driven
+    elsif value == 1
+      expect_data_pin_to_be_released
+    end
+    expect_clock_pin_to_be_released
+    expect_clock_pin_to_be_driven
+  end
+end

data/test/i2c_master_test_helper.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+class I2CMasterTest < TestCase
+  def setup
+    @clock_pin = PiDriver::Pin.new 1
+    @data_pin = PiDriver::Pin.new 2
+    @i2c_master = PiDriver::I2CMaster.new clock_pin: @clock_pin, data_pin: @data_pin
+  end
+
+  private
+
+  def expect_clock_pin_to_be_released
+    @clock_pin.expects(:input).with(nil).in_sequence(@sequence)
+    @clock_pin.expects(:set?).with(nil).returns(true).in_sequence(@sequence)
+  end
+
+  def expect_clock_pin_to_be_driven
+    @clock_pin.expects(:output).with(0).in_sequence(@sequence)
+  end
+
+  def expect_data_pin_to_be_released
+    @data_pin.expects(:input).with(nil).in_sequence(@sequence)
+  end
+
+  def expect_data_pin_to_be_driven
+    @data_pin.expects(:output).with(0).in_sequence(@sequence)
+  end
+end

data/test/pin/test_alias.rb

@@ -0,0 +1,23 @@
+require_relative '../pin_test_helper'
+
+class PinAliasTest < PinTest
+  def test_output_clear_aliases
+    pin = PiDriver::Pin.new @pin_number
+    assert_equal pin.method(:clear), pin.method(:off)
+  end
+
+  def test_output_set_aliases
+    pin = PiDriver::Pin.new @pin_number
+    assert_equal pin.method(:set), pin.method(:on)
+  end
+
+  def test_output_is_clear_aliases
+    pin = PiDriver::Pin.new @pin_number
+    assert_equal pin.method(:clear?), pin.method(:off?)
+  end
+
+  def test_output_is_set_aliases
+    pin = PiDriver::Pin.new @pin_number
+    assert_equal pin.method(:set?), pin.method(:on?)
+  end
+end

data/test/pin/test_clear.rb

@@ -0,0 +1,15 @@
+require_relative '../pin_test_helper'
+
+class PinClearTest < PinTest
+  def test_clear_input
+    pin = PiDriver::Pin.new @pin_number
+    expect_value_write(0).never
+    pin.clear
+  end
+
+  def test_clear_output
+    pin = PiDriver::Pin.new @pin_number, direction: :out, state: 1
+    expect_value_write(0)
+    pin.clear
+  end
+end

data/test/pin/test_clear_interrupt.rb

@@ -0,0 +1,10 @@
+require_relative '../pin_test_helper'
+
+class PinClearInterruptTest < PinTest
+  def test_clear_interrupt
+    pin = PiDriver::Pin.new @pin_number
+    interrupt_thread = pin.interrupt { }
+    interrupt_thread.expects(:kill)
+    pin.clear_interrupt
+  end
+end

data/test/pin/test_error.rb

@@ -0,0 +1,35 @@
+require_relative '../pin_test_helper'
+
+class PinErrorTest < PinTest
+  def test_error_gpio_number
+    assert_raises ArgumentError do
+      PiDriver::Pin.new 17
+    end
+  end
+
+  def test_error_direction
+    assert_raises ArgumentError do
+      PiDriver::Pin.new direction: :invalid_direction
+    end
+  end
+
+  def test_error_value_new
+    assert_raises ArgumentError do
+      PiDriver::Pin.new direction: :out, state: 2
+    end
+  end
+
+  def test_error_value
+    pin = PiDriver::Pin.new @pin_number
+    assert_raises ArgumentError do
+      pin.output 2
+    end
+  end
+
+  def test_error_edge
+    pin = PiDriver::Pin.new @pin_number
+    assert_raises ArgumentError do
+      pin.interrupt(:invalid_edge) { }
+    end
+  end
+end

data/test/pin/test_input.rb

@@ -0,0 +1,23 @@
+require_relative '../pin_test_helper'
+
+class PinInputTest < PinTest
+  def test_input_new_default
+    expect_export_write
+    expect_direction_write(:in)
+    expect_value_read('0')
+    PiDriver::Pin.new @pin_number
+  end
+
+  def test_input_new_ignore_value
+    expect_export_write
+    expect_direction_write(:in)
+    expect_value_read('0')
+    PiDriver::Pin.new @pin_number, state: 1
+  end
+
+  def test_input
+    pin = PiDriver::Pin.new @pin_number, direction: :out
+    expect_direction_write(:in)
+    pin.input
+  end
+end

data/test/pin/test_interrupt.rb

@@ -0,0 +1,51 @@
+require_relative '../pin_test_helper'
+
+class PinInterruptTest < PinTest
+  def test_interrupt
+    pin = PiDriver::Pin.new @pin_number
+    interrupt = mock
+
+    [:rising, :falling, :both, :none].each do |edge|
+      begin
+        PiDriver::Utils::Interrupt.expects(:new).with(edge).returns(interrupt)
+        interrupt.expects(:start)
+        pin.interrupt(edge)
+      ensure
+        interrupt.expects(:clear)
+        pin.clear_interrupt
+      end
+    end
+  end
+
+  def test_interrupt_default
+    pin = PiDriver::Pin.new @pin_number
+
+    begin
+      interrupt_default = sequence('interrupt default')
+      expect_value_read(0).in_sequence(interrupt_default)
+      expect_value_read(1).at_least_once.in_sequence(interrupt_default)
+
+      interrupted = false
+      pin.interrupt { interrupted = true }
+      timeout { interrupted }
+    ensure
+      pin.clear_interrupt
+    end
+  end
+
+  def test_interrupt_argument
+    pin = PiDriver::Pin.new @pin_number
+
+    begin
+      interrupt_argument = sequence('interrupt argument')
+      expect_value_read(1).in_sequence(interrupt_argument)
+      expect_value_read(0).at_least_once.in_sequence(interrupt_argument)
+
+      interrupted = false
+      pin.interrupt(:falling) { interrupted = true }
+      timeout { interrupted }
+    ensure
+      pin.clear_interrupt
+    end
+  end
+end

data/test/pin/test_is_clear.rb

@@ -0,0 +1,17 @@
+require_relative '../pin_test_helper'
+
+class PinIsClearTest < PinTest
+  def test_is_clear_input
+    pin = PiDriver::Pin.new @pin_number
+    expect_value_read('0').twice
+    assert pin.clear?
+    refute pin.set?
+  end
+
+  def test_is_clear_output
+    pin = PiDriver::Pin.new @pin_number, direction: :out
+    expect_value_read('0').never
+    assert pin.clear?
+    refute pin.set?
+  end
+end

data/test/pin/test_is_input.rb

@@ -0,0 +1,14 @@
+require_relative '../pin_test_helper'
+
+class PinIsInputTest < PinTest
+  def test_is_input_new_default
+    pin = PiDriver::Pin.new @pin_number
+    assert pin.input?
+  end
+
+  def test_is_input
+    pin = PiDriver::Pin.new @pin_number, direction: :out
+    pin.input
+    assert pin.input?
+  end
+end

data/test/pin/test_is_output.rb

@@ -0,0 +1,14 @@
+require_relative '../pin_test_helper'
+
+class PinIsOutputTest < PinTest
+  def test_is_output_new
+    pin = PiDriver::Pin.new @pin_number, direction: :out
+    assert pin.output?
+  end
+
+  def test_is_output
+    pin = PiDriver::Pin.new @pin_number
+    pin.output
+    assert pin.output?
+  end
+end