minilab 1.1.0-x86-mswin32-60

data/test/test_helper.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
+
+$LOAD_PATH << "#{APP_ROOT}/test/integration"
+
+%w[ behaviors hardmock-1.3.7 ].each do |lib|
+  $LOAD_PATH << "#{APP_ROOT}/vendor/#{lib}/lib"
+end
+require "behaviors"
+require "hardmock"
+require "assert_error"
+
+require "test/unit"
+class Test::Unit::TestCase
+  extend Behaviors
+end

data/test/unit/analog_io_test.rb

@@ -0,0 +1,54 @@
+require File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
+
+class AnalogIoTest < Test::Unit::TestCase
+  def setup
+    mox = create_mocks(:minilab_wrapper)
+    @target = AnalogIo.new(mox)
+  end
+
+  should "read analog data" do
+    @minilab_wrapper.expects.read_analog(2).returns 5.7
+    assert_equal 5.7, @target.read_analog(2)
+  end
+
+  should "raise an exception when analog input channel is out of range" do
+    # The minilab device has 8 analog inputs (when used in straight
+    # input mode, not differential). We expect that exceptions
+    # should be thrown for channels that are out of bounds.
+    assert_raise(RuntimeError) { @target.read_analog(-1) }
+    0.upto(7) do |channel|
+      @minilab_wrapper.expects.read_analog(channel).returns(1.0)
+      assert_nothing_raised { @target.read_analog(channel) }
+    end
+    assert_raise(RuntimeError) { @target.read_analog(8) }
+  end
+
+  should "write analog data" do
+    @minilab_wrapper.expects.write_analog(1, 4.5)
+    @target.write_analog(1, 4.5)
+  end
+
+  should "raise an error when analog output voltage is out of range" do
+    assert_raise(RuntimeError) { @target.write_analog(0, -0.1) }
+
+    @minilab_wrapper.expects.write_analog(0, 0.0)
+    @minilab_wrapper.expects.write_analog(0, 2.1)
+    @minilab_wrapper.expects.write_analog(0, 5.0)
+    assert_nothing_raised { @target.write_analog(0, 0.0) }
+    assert_nothing_raised { @target.write_analog(0, 2.1) }
+    assert_nothing_raised { @target.write_analog(0, 5.0) }
+
+    assert_raise(RuntimeError) { @target.write_analog(0, 5.1) }
+  end
+  
+  should "raise an error when analog output channel is out of range" do
+    assert_raise(RuntimeError) { @target.write_analog(-1, 0.0) }
+
+    @minilab_wrapper.expects.write_analog(0, 0.0)
+    @minilab_wrapper.expects.write_analog(1, 0.0)
+    assert_nothing_raised { @target.write_analog(0, 0.0) }
+    assert_nothing_raised { @target.write_analog(1, 0.0) }
+
+    assert_raise(RuntimeError) { @target.write_analog(2, 0.0) }
+  end
+end

data/test/unit/connection_state_test.rb

@@ -0,0 +1,18 @@
+require File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
+
+class ConnectionStateTest < Test::Unit::TestCase
+  def setup
+    @target = ConnectionState.new
+  end
+
+  should "default to an unconnected state" do
+    assert_equal false, @target.connected?
+  end
+
+  should "allow the connection state to be changed" do
+    @target.connected = true
+    assert_equal true, @target.connected?
+    @target.connected = false
+    assert_equal false, @target.connected?
+  end
+end

data/test/unit/digital_auxport_io_test.rb

@@ -0,0 +1,102 @@
+require File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
+
+class DigitalAuxportIoTest < Test::Unit::TestCase
+  include MinilabConstants
+
+  def setup
+    mox = create_mocks(:minilab_wrapper)
+    @target = DigitalAuxportIo.new(mox)
+  end
+
+  should "read digital data from the screw terminals" do
+    expected_configuration = { :direction => DIGITALIN, :pin => get_pin_number("DIO1") }
+    @minilab_wrapper.expects.configure_auxport(expected_configuration)
+    @minilab_wrapper.expects.read_auxport(get_pin_number("DIO1")).returns 1
+
+    assert_equal 1, @target.read_digital('DIO1')
+  end
+
+  should "raise an error when digital input pin is not valid" do
+    make_sure_bad_pins_blow_up
+
+    good_pins.each do |pin|
+      expected_configuration = { :direction => DIGITALIN, :pin => get_pin_number(pin) }
+      @minilab_wrapper.expects.configure_auxport(expected_configuration)
+      @minilab_wrapper.expects.read_auxport(get_pin_number(pin)).returns 0
+      assert_nothing_raised { @target.read_digital(pin) }
+    end
+  end
+
+  # Output tests
+  should "write digital data to the screw terminals" do
+    expected_configuration = { :direction => DIGITALOUT, :pin => get_pin_number("DIO1") }
+    @minilab_wrapper.expects.configure_auxport(expected_configuration)
+    @minilab_wrapper.expects.write_auxport(get_pin_number("DIO1"), 1)
+
+    @target.write_digital("DIO1", 1)
+  end
+
+  should "write 1 to a digital output when the commanded value is anything not 0" do
+    expected_configuration = { :direction => DIGITALOUT, :pin => get_pin_number("DIO1") }
+    @minilab_wrapper.expects.configure_auxport(expected_configuration)
+    @minilab_wrapper.expects.write_auxport(get_pin_number("DIO1"), 1)
+    @target.write_digital("DIO1", 173)
+
+    @minilab_wrapper.expects.configure_auxport(expected_configuration)
+    @minilab_wrapper.expects.write_auxport(get_pin_number("DIO1"), 1)
+    @target.write_digital("DIO1", 872)
+  end
+
+  should "raise an exception if someone tries to command a negative value" do
+    assert_raise(RuntimeError) { @target.write_digital("DIO2", -1) }
+    assert_raise(RuntimeError) { @target.write_digital("DIO2", -80) }
+  end
+  
+  should "raise an exception when digital output pin is out of range" do
+    make_sure_bad_pins_blow_up
+
+    good_pins.each do |pin|
+      expected_configuration = { :direction => DIGITALOUT, :pin => get_pin_number(pin) }
+      @minilab_wrapper.expects.configure_auxport(expected_configuration)
+      @minilab_wrapper.expects.write_auxport(get_pin_number(pin), 1)
+      assert_nothing_raised { @target.write_digital(pin, 1) }
+    end
+  end
+
+  should "accept case-insensitive DIO strings as pins" do
+    expected_configuration = { :direction => DIGITALOUT, :pin => get_pin_number("DIO1") }
+    @minilab_wrapper.expects.configure_auxport(expected_configuration)
+    @minilab_wrapper.expects.write_auxport(get_pin_number("DIO1"), 1)
+    @target.write_digital('dio1', 1)
+
+    expected_configuration = { :direction => DIGITALOUT, :pin => get_pin_number("DIO2") }
+    @minilab_wrapper.expects.configure_auxport(expected_configuration)
+    @minilab_wrapper.expects.write_auxport(get_pin_number("DIO2"), 1)
+    @target.write_digital('dIo2', 1)
+
+    expected_configuration = { :direction => DIGITALIN, :pin => get_pin_number("DIO0") }
+    @minilab_wrapper.expects.configure_auxport(expected_configuration)
+    @minilab_wrapper.expects.read_auxport(get_pin_number("DIO0")).returns 1
+    @target.read_digital('DiO0')
+
+    expected_configuration = { :direction => DIGITALIN, :pin => get_pin_number("DIO3") }
+    @minilab_wrapper.expects.configure_auxport(expected_configuration)
+    @minilab_wrapper.expects.read_auxport(get_pin_number("DIO3")).returns 1
+    @target.read_digital('diO3')
+  end
+
+  private
+  def get_pin_number(pin)
+    pin.match(/(\d)$/)[0].to_i
+  end
+
+  def good_pins
+    %w[ DIO0 DIO1 DIO2 DIO3 ]
+  end
+
+  def make_sure_bad_pins_blow_up
+    [ 'yourmom', 'bill', nil, false, 55, 'DIO4', -1, 38 ].each do |pin|
+      assert_raise(RuntimeError) { @target.read_digital(pin) }
+    end
+  end
+end

data/test/unit/digital_configuration_test.rb

@@ -0,0 +1,100 @@
+require File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
+
+class DigitalConfigurationTest < Test::Unit::TestCase
+  include MinilabConstants
+
+  def setup
+    mox = create_mocks(:minilab_wrapper)
+    @target = DigitalConfiguration.new(mox)
+  end
+
+  should "configure known ports for input" do
+    good_ports.each do |port|
+      expected_configuration = { :direction => DIGITALIN, :port => port_to_library_port_mapping[port] }
+      @minilab_wrapper.expects.configure_port(expected_configuration).returns "you"
+    end
+
+    good_ports.each do |port|
+      assert_equal true, @target.configure_port_for_input(port)
+    end
+  end
+  
+  should "configure known ports for output" do
+    good_ports.each do |port|
+      expected_configuration = { :direction => DIGITALOUT, :port => port_to_library_port_mapping[port] }
+      @minilab_wrapper.expects.configure_port(expected_configuration).returns "boo"
+    end
+
+    good_ports.each do |port|
+      assert_equal true, @target.configure_port_for_output(port)
+    end
+  end
+  
+  should "raise an error for an invalid input port" do
+    check_error_for_all_bad_ports(:configure_port_for_input)
+  end
+
+  should "raise an error for an invalid output port" do
+    check_error_for_all_bad_ports(:configure_port_for_output)
+  end
+
+  should "return false when each of the ports has not been configured for input yet and a client asks if it has" do
+    good_ports.each do |port|
+      assert_equal false, @target.is_port_configured_for_input?(port)
+    end
+  end
+
+  should "return false when each of the ports has not been configured for output yet and a client asks if it has" do
+    good_ports.each do |port|
+      assert_equal false, @target.is_port_configured_for_output?(port)
+    end
+  end
+
+  should "return the input configuration status of a port when asked" do
+    expected_configuration = { :direction => DIGITALIN, :port => port_to_library_port_mapping[:porta] }
+    @minilab_wrapper.expects.configure_port(expected_configuration).returns true
+
+    @target.configure_port_for_input(:porta)
+    assert_equal true, @target.is_port_configured_for_input?(:porta)
+  end
+  
+  should "return the output configuration status of a port when asked" do
+    expected_configuration = { :direction => DIGITALOUT, :port => port_to_library_port_mapping[:portb] }
+    @minilab_wrapper.expects.configure_port(expected_configuration).returns true
+
+    @target.configure_port_for_output(:portb)
+    assert_equal true, @target.is_port_configured_for_output?(:portb)
+  end
+  
+  should "raise an error if you pass is_port_configured_for_input? an invalid port" do
+    check_error_for_all_bad_ports(:is_port_configured_for_input?)
+  end
+  
+  should "raise an error if you pass is_port_configured_for_output? an invalid port" do
+    check_error_for_all_bad_ports(:is_port_configured_for_output?)
+  end
+
+  private
+  def good_ports
+    [:porta, :portb, :portcl, :portch]
+  end
+
+  def bad_ports
+    [nil, :portd, :portttt, "ibm"]
+  end
+
+  def port_to_library_port_mapping
+    {
+      :porta => FIRSTPORTA,
+      :portb => FIRSTPORTB,
+      :portcl => FIRSTPORTCL,
+      :portch => FIRSTPORTCH
+    }
+  end
+
+  def check_error_for_all_bad_ports(method_to_test)
+    bad_ports.each do |bad_port|
+      assert_raise(RuntimeError) { @target.send(method_to_test, bad_port) }
+    end
+  end
+end

data/test/unit/digital_port_io_test.rb

@@ -0,0 +1,67 @@
+require File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
+
+class DigitalPortIoTest < Test::Unit::TestCase
+  def setup
+    mox = create_mocks(:minilab_wrapper, :digital_configuration, :library_translator)
+    @target = DigitalPortIo.new(mox)
+  end
+
+  # configuration tests
+  should "use the digital configuration object to configure a port for input" do
+    @digital_configuration.expects.configure_port_for_input(:portch).returns(true)
+    assert @target.configure_input_port(:portch)
+  end
+
+  should "use the digital configuration object to configure a port for output" do
+    @digital_configuration.expects.configure_port_for_output(:portcl).returns(true)
+    assert @target.configure_output_port(:portcl)
+  end
+
+  # read tests
+  should "read digital input from the digital pins" do
+    @library_translator.expects.get_port_for_pin(1).returns(:porta)
+    @digital_configuration.expects.is_port_configured_for_input?(:porta).returns(true)
+    @library_translator.expects.get_library_pin_number(1).returns(21)
+    @minilab_wrapper.expects.read_digital_pin(21).returns "woohoo"
+
+    assert_equal "woohoo", @target.read_digital(1)
+  end
+
+  should "read digital input from a digital port" do
+    @digital_configuration.expects.is_port_configured_for_input?(:portb).returns(true)
+    @library_translator.expects.get_library_port(:portb).returns("some port")
+    @minilab_wrapper.expects.read_port("some port").returns 0x34
+
+    assert_equal 0x34, @target.read_port(:portb)
+  end
+
+  should "raise an error when the configuration object says the port isn't configured for input when reading a pin" do
+    @library_translator.expects.get_port_for_pin(20).returns(:portc)
+    @digital_configuration.expects.is_port_configured_for_input?(:portc).returns(false)
+
+    assert_raise (RuntimeError) { @target.read_digital(20) }
+  end
+
+  should "raise an error when the configuration objects says the port isn't configured for input when reading a port" do
+    @digital_configuration.expects.is_port_configured_for_input?(:porta).returns(false)
+
+    assert_raise (RuntimeError) { @target.read_port(:porta) }
+  end
+
+  # output tests
+  should "write digital output to a digital pin" do
+    @library_translator.expects.get_port_for_pin(2).returns(:portcl)
+    @digital_configuration.expects.is_port_configured_for_output?(:portcl).returns(true)
+    @library_translator.expects.get_library_pin_number(2).returns(7)
+    @minilab_wrapper.expects.write_digital_pin(7, 0).returns "ibm"
+
+    assert_equal true, @target.write_digital(2, 0)
+  end
+  
+  should "raise an error when the configuration object says the port is not configured for output (for write_digital)" do
+    @library_translator.expects.get_port_for_pin(1).returns(:portd)
+    @digital_configuration.expects.is_port_configured_for_output?(:portd).returns(false)
+
+    assert_raise (RuntimeError) { @target.write_digital(1, 1) }
+  end
+end

data/test/unit/library_translator_test.rb

@@ -0,0 +1,98 @@
+require File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
+
+class LibraryTranslatorTest < Test::Unit::TestCase
+  include MinilabConstants
+
+  def setup
+    @target = LibraryTranslator.new
+  end
+
+  def teardown
+  end
+
+  def check_pins_and_ports(low, high, port)
+    low.upto(high) do |pin|
+      assert_equal port, @target.get_port_for_pin(pin), "Didn't get #{port} for pin #{pin}"
+    end
+  end
+
+  # tests
+  should "provide :porta when asked about numbered pins on the hardware's FIRSTPORTA" do
+    check_pins_and_ports(30, 37, :porta)
+  end
+
+  should "provide :portb when asked about numbered pins on the hardware's FIRSTPORTB" do
+    check_pins_and_ports(3, 10, :portb)
+  end
+
+  should "provide :portcl when asked about numbered pins on the hardware's FIRSTPORTCL" do
+    check_pins_and_ports(26, 29, :portcl)
+  end
+
+  should "provide :portch when asked about numbered pins on the hardware's FIRSTPORTCH" do
+    check_pins_and_ports(22, 25, :portch)
+  end
+
+  should "raise an error when asked about a pin number that does not map to a port (such as the pins for ground, 5v +ve, DIO1..3, etc)" do
+    [ 1, 2, "DIO0", "DIO2", nil, :thedude, 832].each do |bad_pin|
+      assert_raise(RuntimeError) { @target.get_port_for_pin(bad_pin) }
+    end
+  end
+
+  should "get the number the library uses for the pin when asked to translate from the numbers on the board (port a pins)" do
+    assert_equal 7, @target.get_library_pin_number(30)
+    assert_equal 6, @target.get_library_pin_number(31)
+    assert_equal 5, @target.get_library_pin_number(32)
+    assert_equal 4, @target.get_library_pin_number(33)
+    assert_equal 3, @target.get_library_pin_number(34)
+    assert_equal 2, @target.get_library_pin_number(35)
+    assert_equal 1, @target.get_library_pin_number(36)
+    assert_equal 0, @target.get_library_pin_number(37)
+  end
+
+  should "get the number the library uses for the pin when asked to translate from the numbers on the board (port b pins)" do
+    assert_equal 15, @target.get_library_pin_number(3)
+    assert_equal 14, @target.get_library_pin_number(4)
+    assert_equal 13, @target.get_library_pin_number(5)
+    assert_equal 12, @target.get_library_pin_number(6)
+    assert_equal 11, @target.get_library_pin_number(7)
+    assert_equal 10, @target.get_library_pin_number(8)
+    assert_equal 9, @target.get_library_pin_number(9)
+    assert_equal 8, @target.get_library_pin_number(10)
+  end
+  
+  should "get the number the library uses for the pin when asked to translate from the numbers on the board (port cl pins)" do
+    assert_equal 19, @target.get_library_pin_number(26)
+    assert_equal 18, @target.get_library_pin_number(27)
+    assert_equal 17, @target.get_library_pin_number(28)
+    assert_equal 16, @target.get_library_pin_number(29)
+  end
+  
+  should "get the number the library uses for the pin when asked to translate from the numbers on the board (port ch pins)" do
+    assert_equal 23, @target.get_library_pin_number(22)
+    assert_equal 22, @target.get_library_pin_number(23)
+    assert_equal 21, @target.get_library_pin_number(24)
+    assert_equal 20, @target.get_library_pin_number(25)
+  end
+
+  should "raise an error if the pin passed in to get_library_pin_number is invalid" do
+    [20, 21, nil, 12, :heynow, "uba"].each do |bad_pin|
+      assert_raise(RuntimeError) { @target.get_library_pin_number(bad_pin) }
+    end
+  end
+
+  should "know the mapping between symbolic ports and ports in the library" do
+    assert_equal FIRSTPORTA, @target.get_library_port(:porta), "wrong port"
+    assert_equal FIRSTPORTB, @target.get_library_port(:portb), "wrong port"
+    assert_equal FIRSTPORTCL, @target.get_library_port(:portcl), "wrong port"
+    assert_equal FIRSTPORTCH, @target.get_library_port(:portch), "wrong port"
+  end
+
+  should "raise an error if asked about the library port that does not exist" do
+    [:portd, :portci, "cigarette butt", nil].each do |bad_port|
+      assert_error RuntimeError, "Port #{bad_port} is not a valid port." do
+        @target.get_library_port(bad_port)
+      end
+    end
+  end 
+end