minilab 1.0.0-mswin32

data/test/test_helper.rb

@@ -0,0 +1,11 @@
+require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
+
+require 'test/unit'
+require 'behaviors'
+require 'hardmock'
+
+$LOAD_PATH << File.join(APP_ROOT + '/test/integration')
+
+class Test::Unit::TestCase
+  extend Behaviors
+end

data/test/unit/analog_io_test.rb

@@ -0,0 +1,87 @@
+require File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
+require 'analog_io'
+
+class AnalogIoTest < Test::Unit::TestCase
+  def setup
+    mox = create_mocks(:minilab_hardware, :result_verifier)
+    @target = AnalogIo.new(mox)
+  end
+
+  # helpers.
+  def expects_read_analog_and_result_verification(channel, value)
+    result = { :value => value }
+    @minilab_hardware.expects.read_analog(channel).returns(result)
+    @result_verifier.expects.verify(result, "read_analog")
+  end
+
+  def expects_write_analog_and_result_verification(channel, volts)
+    result = { :laptop => "heavy" }
+    @minilab_hardware.expects.write_analog(channel, volts).returns(result)
+    @result_verifier.expects.verify(result, "write_analog")
+  end
+
+  # Input tests
+  should "read analog data" do
+    expects_read_analog_and_result_verification(2, 5.7)
+    assert_equal 5.7, @target.read_analog(2)
+
+    expects_read_analog_and_result_verification(2, 0.0)
+    assert_equal 0.0, @target.read_analog(2)
+
+    expects_read_analog_and_result_verification(1, -5.2)
+    assert_equal -5.2, @target.read_analog(1)
+  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 expects that exceptions
+    # should be thrown for channels that are out of bounds.
+    # We expect that the class will access the minilab hardware
+    # if the channel *is* in range. Thus, we need to do this
+    # in order to make the mock happy...
+    8.times do |channel|
+      expects_read_analog_and_result_verification(channel, 1.0)
+    end
+
+    assert_raise(RuntimeError) { @target.read_analog(-1) }
+    0.upto(7) do |channel|
+      assert_nothing_raised { @target.read_analog(channel) }
+    end
+    assert_raise(RuntimeError) { @target.read_analog(8) }
+  end
+
+  # Output tests
+  should "write analog data" do
+    expects_write_analog_and_result_verification(1, 4.5)
+    @target.write_analog(1, 4.5)
+
+    expects_write_analog_and_result_verification(1, 2.5)
+    @target.write_analog(1, 2.5)
+
+    expects_write_analog_and_result_verification(0, 1.3)
+    @target.write_analog(0, 1.3)
+  end
+
+  should "raise an error when analog output voltage is out of range" do
+    expects_write_analog_and_result_verification(0, 0.0)
+    expects_write_analog_and_result_verification(0, 2.1)
+    expects_write_analog_and_result_verification(0, 5.0)
+
+    assert_raise(RuntimeError) { @target.write_analog(0, -0.1) }
+    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
+    2.times do |channel|
+      expects_write_analog_and_result_verification(channel, 0.0)
+    end
+
+    assert_raise(RuntimeError) { @target.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/digital_auxport_io_test.rb

@@ -0,0 +1,114 @@
+require File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
+require 'digital_auxport_io'
+
+class DigitalAuxportIoTest < Test::Unit::TestCase
+  include MinilabConstants
+  def setup
+    mox = create_mocks(:minilab_hardware, :result_verifier)
+    @target = DigitalAuxportIo.new(mox)
+    
+    @good_pins = ['DIO0', 'DIO1', 'DIO2', 'DIO3']
+    @bad_pins = ['yourmom', 'bill', nil, false, 55, 'DIO4', -1, 38]
+  end
+
+  # Input tests
+  should "read digital data from the screw terminals" do
+    expect_read_auxport_and_verification('DIO1', 1)
+    assert_equal 1, @target.read_digital('DIO1')
+
+    expect_read_auxport_and_verification('DIO2', 0)
+    assert_equal 0, @target.read_digital('DIO2')
+  end
+
+  should "raise an exception when digital input pin is not valid" do
+    make_sure_bad_pins_blow_up
+
+    @good_pins.each do |pin|
+      expect_read_auxport_and_verification(pin, 1)
+      assert_nothing_raised { @target.read_digital(pin) }
+    end
+  end
+
+  # Output tests
+  should "write digital data to the screw terminals" do
+    expect_write_auxport_and_verification('DIO1', 1)
+    @target.write_digital('DIO1', 1)
+
+    expect_write_auxport_and_verification('DIO1', 0)
+    @target.write_digital('DIO1', 0)
+
+    expect_write_auxport_and_verification('DIO3', 1)
+    @target.write_digital('DIO3', 1)
+  end
+
+  should "write 1 to a digital output when the commanded value is anything not 0" do
+    expect_write_auxport_and_verification('DIO2', 1)
+    @target.write_digital('DIO2', 173)
+
+    expect_write_auxport_and_verification('DIO2', 1)
+    @target.write_digital('DIO2', 2902)
+  end
+
+  should "raise an exception if someone tries to command a negative value" do
+    assert_raise(RuntimeError) { @target.write_digital('DIO2', -10) }
+    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|
+      expect_write_auxport_and_verification(pin, 1)
+      assert_nothing_raised { @target.write_digital(pin, 1) }
+    end
+  end
+
+  should "accept case-insensitive DIO strings as pins" do
+    expect_write_auxport_and_verification('dio1', 1)
+    @target.write_digital('dio1', 1)
+
+    expect_write_auxport_and_verification('dIo2', 1)
+    @target.write_digital('dIo2', 1)
+
+    expect_read_auxport_and_verification('DiO0', 0)
+    @target.read_digital('DiO0')
+
+    expect_read_auxport_and_verification('diO3', 0)
+    @target.read_digital('diO3')
+  end
+
+  private
+  def get_pin_number(pin)
+    pin.match(/(\d)$/)[0].to_i
+  end
+
+  def expect_read_auxport_and_verification(pin, value)
+    pin = get_pin_number(pin)
+    configuration = { :direction => DIGITALIN, :pin => pin }
+    result1 = { :dell => 4, :keyboard => 7 }
+    @minilab_hardware.expects.configure_auxport(configuration).returns(result1)
+    @result_verifier.expects.verify(result1, "configure_auxport_in")
+
+    result2 = { :value => value }
+    @minilab_hardware.expects.read_auxport(pin).returns(result2)
+    @result_verifier.expects.verify(result2, "read_auxport")
+  end
+
+  def expect_write_auxport_and_verification(pin, value)
+    pin = get_pin_number(pin)
+    configuration = { :direction => DIGITALOUT, :pin => pin }
+    result1 = { :stand => 2 }
+    @minilab_hardware.expects.configure_auxport(configuration).returns(result1)
+    @result_verifier.expects.verify(result1, "configure_auxport_out")
+
+    result2 = { :card => "numerous" }
+    @minilab_hardware.expects.write_auxport(pin, value).returns(result2)
+    @result_verifier.expects.verify(result2, "write_auxport")
+  end
+
+  def make_sure_bad_pins_blow_up
+    @bad_pins.each do |pin|
+      assert_raise(RuntimeError) { @target.read_digital(pin) }
+    end
+  end
+end

data/test/unit/digital_configuration_test.rb

@@ -0,0 +1,136 @@
+require File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
+require 'digital_configuration'
+require 'extension/minilab_hardware'
+
+class DigitalConfigurationTest < Test::Unit::TestCase
+  include MinilabConstants
+
+  def setup
+    mox = create_mocks(:minilab_hardware, :result_verifier)
+    @target = DigitalConfiguration.new(mox)
+
+    @good_ports = [:porta, :portb, :portcl, :portch]
+    @port_to_library_port_mapping = {
+      :porta => FIRSTPORTA,
+      :portb => FIRSTPORTB,
+      :portcl => FIRSTPORTCL,
+      :portch => FIRSTPORTCH
+    }
+
+    @bad_ports = [nil, :portd, :portttt, "ibm"]
+  end
+
+  def expect_configure_input_and_verification
+    result = { :hey => "you" }
+
+    @good_ports.each do |port|
+      expected_configuration = { :direction => DIGITALIN, :port => @port_to_library_port_mapping[port] }
+      @minilab_hardware.expects.configure_port(expected_configuration).returns(result)
+      @result_verifier.expects.verify(result)
+    end
+  end
+
+  def expect_configure_output_and_verification
+    result = { :woo => "boo" }
+
+    @good_ports.each do |port|
+      expected_configuration = { :direction => DIGITALOUT, :port => @port_to_library_port_mapping[port] }
+      @minilab_hardware.expects.configure_port(expected_configuration).returns(result)
+      @result_verifier.expects.verify(result)
+    end
+  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
+
+  should "know the valid ports" do
+    expected_ports = [:porta, :portb, :portcl, :portch]
+    actual_ports = @target.get_valid_ports
+
+    assert_equal expected_ports.size, actual_ports.size
+    expected_ports.each_with_index do |port, index|
+      assert_equal port, actual_ports[index]
+    end
+  end
+  
+  should "configure a port for input" do
+    expect_configure_input_and_verification
+
+    @good_ports.each do |port|
+      assert_equal true, @target.configure_port_for_input(port)
+    end
+  end
+  
+  should "configure a port for output" do
+    expect_configure_output_and_verification
+
+    @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
+    result = {:a => "b"}
+    expected_configuration = { :direction => DIGITALIN, :port => @port_to_library_port_mapping[:porta] }
+    @minilab_hardware.expects.configure_port(expected_configuration).returns(result)
+    @result_verifier.expects.verify(result)
+
+    @target.configure_port_for_input(:porta)
+    assert_equal true, @target.is_port_configured_for_input?(:porta)
+    
+    expected_configuration = { :direction => DIGITALIN, :port => @port_to_library_port_mapping[:portch] }
+    @minilab_hardware.expects.configure_port(expected_configuration).returns(result)
+    @result_verifier.expects.verify(result)
+
+    @target.configure_port_for_input(:portch)
+    assert_equal true, @target.is_port_configured_for_input?(:portch)
+  end
+  
+  should "return the output configuration status of a port when asked" do
+    result = {:keyboard => "mouse"}
+    expected_configuration = { :direction => DIGITALOUT, :port => @port_to_library_port_mapping[:portb] }
+    @minilab_hardware.expects.configure_port(expected_configuration).returns(result)
+    @result_verifier.expects.verify(result)
+
+    @target.configure_port_for_output(:portb)
+    assert_equal true, @target.is_port_configured_for_output?(:portb)
+    
+    expected_configuration = { :direction => DIGITALOUT, :port => @port_to_library_port_mapping[:portcl] }
+    @minilab_hardware.expects.configure_port(expected_configuration).returns(result)
+    @result_verifier.expects.verify(result)
+
+    @target.configure_port_for_output(:portcl)
+    assert_equal true, @target.is_port_configured_for_output?(:portcl)
+  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
+end

data/test/unit/digital_port_io_test.rb

@@ -0,0 +1,117 @@
+require File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
+require 'digital_port_io'
+
+class DigitalPortIoTest < Test::Unit::TestCase
+
+  def setup
+    @good_ports = [:porta, :portb, :portcl, :portch]
+
+    mox = create_mocks(:minilab_hardware, :result_verifier,
+                       :digital_configuration, :library_translator)
+    @target = DigitalPortIo.new(mox)
+  end
+
+  # configuration tests
+  should "get the list of valid ports from the configuration object" do
+    ports = [:porta, "signal", 1]
+    @digital_configuration.expects.get_valid_ports().returns(ports)
+
+    assert_same ports, @target.get_valid_ports
+  end
+
+  should "use the digital configuration object to configure a port for input" do
+    @digital_configuration.expects.configure_port_for_input(:porta).returns(true)
+    @target.configure_input_port(:porta)
+    
+    @digital_configuration.expects.configure_port_for_input(:portch).returns(true)
+    assert_equal true, @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(:portb).returns(true)
+    assert @target.configure_output_port(:portb)
+
+    @digital_configuration.expects.configure_port_for_output(:portcl).returns(true)
+    assert_equal true, @target.configure_output_port(:portcl)
+  end
+
+  # read tests
+  should "read digital input from the digital pins" do
+    pin = 1
+
+    @library_translator.expects.get_port_for_pin(pin).returns(:porta)
+    @digital_configuration.expects.is_port_configured_for_input?(:porta).returns(true)
+    @library_translator.expects.get_library_pin_number(pin).returns(21)
+
+    result = { :value => "woohoo" }
+    @minilab_hardware.expects.read_digital_pin(21).returns(result)
+    @result_verifier.expects.verify(result)
+
+    assert_equal "woohoo", @target.read_digital(pin)
+  end
+
+  should "read digital input from a digital port" do
+    result = { :value => 0x34 }
+    @digital_configuration.expects.get_valid_ports.returns(@good_ports)
+    @digital_configuration.expects.is_port_configured_for_input?(:portb).returns(true)
+    @library_translator.expects.get_library_port(:portb).returns("some port")
+    @minilab_hardware.expects.read_port("some port").returns(result)
+    @result_verifier.expects.verify(result)
+
+    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.get_valid_ports.returns(@good_ports)
+    @digital_configuration.expects.is_port_configured_for_input?(:porta).returns(false)
+
+    assert_raise (RuntimeError) { @target.read_port(:porta) }
+  end
+
+  should "raise an error when the port passed for read_port does not exist" do
+    @good_ports.each do |port|
+      result = { :value => 0x34 }
+      @digital_configuration.expects.get_valid_ports.returns(@good_ports)
+      @digital_configuration.expects.is_port_configured_for_input?(port).returns(true)
+      @library_translator.expects.get_library_port(port).returns("some port")
+      @minilab_hardware.expects.read_port("some port").returns(result)
+      @result_verifier.expects.verify(result)
+
+      assert_equal 0x34, @target.read_port(port)    
+    end
+
+   [nil, 0, false, :laptop, :portd].each do |bad_port|
+      @digital_configuration.expects.get_valid_ports.returns(@good_ports)
+      assert_raise(RuntimeError) { @target.read_port(bad_port) }
+   end
+  end
+
+  # output tests
+  should "write digital output to a digital pin" do
+    pin = 2
+    value = 0
+
+    @library_translator.expects.get_port_for_pin(pin).returns(:portcl)
+    @digital_configuration.expects.is_port_configured_for_output?(:portcl).returns(true)
+    @library_translator.expects.get_library_pin_number(pin).returns(7)
+    result = { :value => "ibm" }
+    @minilab_hardware.expects.write_digital_pin(7, value).returns(result)
+    @result_verifier.expects.verify(result)
+
+    assert_equal true, @target.write_digital(pin, value)
+  end
+  
+  should "raise an exception 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