minilab 1.0.0-mswin32

data/test/unit/library_translator_test.rb

@@ -0,0 +1,100 @@
+require File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
+require 'library_translator'
+require 'extension/minilab_hardware'
+
+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

data/test/unit/minilab_context_test.rb

@@ -0,0 +1,82 @@
+require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+require "minilab_context"
+require "minilab"
+
+class MinilabContextTest < Test::Unit::TestCase
+  def setup
+    MinilabContext.clear
+    @target = MinilabContext.new
+  end
+
+  def build_context
+    context = nil
+
+    assert_nothing_raised "should build without error" do
+      context = @target.build
+    end
+    assert_not_nil context, "should have gotten a context"
+
+    context
+  end
+
+  should "build minilab context" do
+    context = build_context
+
+    minilab = context[:minilab]
+    assert_not_nil minilab, "should have a minilab object in the context"
+    assert_kind_of Minilab, minilab, "should have gotten a Minilab object"
+  end
+
+  should "allow for the context to be cleared" do
+    first_context = @target.build
+    MinilabContext.clear
+    second_context = @target.build
+
+    assert_not_same first_context, second_context, "context should have been cleared and rebuilt"
+  end
+
+  should "return the same context when built more than once" do
+    first_context = build_context
+    second_context = build_context
+
+    assert_same first_context, second_context, "not the same context object"
+  end
+
+  should "allow arbitrary objects to be injected into the context before it is built" do
+    create_mock(:minilab_hardware)
+    MinilabContext.inject(:object => :minilab_hardware, :instance => @minilab_hardware)
+
+    context = build_context
+    minilab = context[:minilab_hardware]
+    assert_same @minilab_hardware, minilab, "not the same object was returned from the context as was injected"
+
+    create_mock(:kryll)
+    MinilabContext.inject(:object => :kryll, :instance => @kryll)
+
+    context = build_context
+    kryll = context[:kryll]
+    assert_same @kryll, kryll, "not the same object was returned from the context as was injected"
+  end
+  
+  should "blow up if trying to inject an object without the appropriate parameters" do
+    assert_error RuntimeError, /missing parameter :object/i do
+      MinilabContext.inject(:instance => "foo")
+    end
+
+    assert_error RuntimeError, /missing parameter :instance/i do
+      MinilabContext.inject(:object => "foo")
+    end
+
+    assert_error RuntimeError, /parameters hash was nil/i do
+      MinilabContext.inject(nil)
+    end
+  end
+  
+  should "raise an error if trying to inject an object into the context after it has been built" do
+    @target.build
+
+    assert_error RuntimeError, /minilab_hardware/i do
+      MinilabContext.inject(:object => 'minilab_hardware', :instance => "kaboo")
+    end
+  end
+end

data/test/unit/minilab_hardware_test.rb

@@ -0,0 +1,83 @@
+require File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
+require 'extension/minilab_hardware'
+
+# The intent of this test is to assert some basic properties on the extension.
+# Typically I would not check these things, but this class is made from C code.
+# Even though it's easy to create Ruby constants, methods, etc. with Ruby's C
+# support, it's still more work than it takes in Ruby syntax. So here I'm
+# trying to show that the stuff we expect to be there is actually there. It's
+# also here to help pinpoint any problems that may not show up until system test
+# time.
+#
+# Outside of the tests for checking hash parameters, I'm willing to discuss
+# whether maintaining this set of tests is truly worthwhile. I may change my
+# mind.
+class MinilabHardwareTest < Test::Unit::TestCase
+  include MinilabConstants
+
+  def setup
+    @target = MinilabHardware.new
+  end
+
+  should "have expected constants" do
+    [
+      :DONTPRINT,
+      :STOPALL,
+      :CURRENTREVNUM,
+      :DIGITALIN,
+      :DIGITALOUT,
+      :FIRSTPORTA,
+      :FIRSTPORTB,
+      :FIRSTPORTCL,
+      :FIRSTPORTCH
+    ].each do |constant|
+      assert MinilabConstants.const_defined?(constant), "#{constant} should exist as a constant in MinilabConstants"
+    end
+  end
+
+  should "have the expected methods" do
+    expected_methods =
+    [ 
+      :setup_error_handling,
+      :declare_revision,
+      :get_revision,
+      :get_error_string,
+
+      :configure_auxport,
+      :configure_port,
+
+      :read_analog,
+      :read_digital_pin,
+      :read_auxport,
+      :read_port,
+
+      :write_analog,
+      :write_digital_pin,
+      :write_auxport,
+    ]
+
+    expected_methods.each do |method|
+      assert @target.respond_to?(method), "Minilab hardware object does not respond to #{method.to_s}"
+    end
+  end
+
+  should "raise an error if auxport configuration isn't given the correct hash parameters" do
+    assert_error RuntimeError, ":direction is a required parameter" do
+      @target.configure_auxport(:pin => 3)
+    end
+
+    assert_error RuntimeError, ":pin is a required parameter" do
+      @target.configure_auxport(:direction => DIGITALIN)
+    end
+  end
+
+  should "raise an error if port configuration isn't given the correct hash parameters" do
+    assert_error RuntimeError, ":direction is a required parameter" do
+      @target.configure_port(:port => FIRSTPORTA)
+    end
+
+    assert_error RuntimeError, ":port is a required parameter" do
+      @target.configure_port(:direction => DIGITALOUT)
+    end
+  end
+end

data/test/unit/minilab_test.rb

@@ -0,0 +1,131 @@
+require File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
+require 'Minilab'
+require 'extension/minilab_hardware'
+
+class MinilabTest < Test::Unit::TestCase
+  include MinilabConstants
+
+  def setup
+    mox = create_mocks(:minilab_hardware, :result_verifier, :analog_io,
+                       :digital_auxport_io, :digital_port_io)
+    @minilab = Minilab.new(mox)
+  end
+
+  should "allow the user to easily build the minilab object and its dependences" do
+    minilab = nil
+
+    assert_nothing_raised "should build without error" do
+      minilab = Minilab.build
+    end
+
+    assert_not_nil minilab, "should have gotten an object"
+    assert_kind_of Minilab, minilab, "should have gotten a Minilab object"
+  end
+
+  should "connect to the hardware, setup the error handling, declare the library revision, and setup the db37 ports for input" do
+    connect
+  end
+
+  should "bomb out if trying to use a method but haven't connected yet" do
+    assert_not_connected_error { @minilab.read_analog(0) }
+    assert_not_connected_error { @minilab.write_analog(0, 2.2) }
+    assert_not_connected_error { @minilab.read_digital(6) }
+    assert_not_connected_error { @minilab.write_digital(6, 1) }
+    assert_not_connected_error { @minilab.read_digital_byte(:porta) }
+    assert_not_connected_error { @minilab.configure_input_port(:portcl) }
+    assert_not_connected_error { @minilab.configure_output_port(:portb) }
+  end
+
+  # IO tests
+  should "read analog input" do
+    connect
+    @analog_io.expects.read_analog(4).returns(1.1)
+
+    assert_equal 1.1, @minilab.read_analog(4)
+  end
+  
+  should "write analog output" do
+    connect
+    @analog_io.expects.write_analog(1, 5.9).returns(true)
+
+    @minilab.write_analog(1, 5.9)
+  end
+
+  should "read digital input from the DIO auxport terminals" do
+    connect
+    @digital_auxport_io.expects.read_digital('DIO1').returns(1)
+
+    assert_equal 1, @minilab.read_digital('DIO1')
+  end
+
+  should "write digital output to the DIO auxport terminals" do
+    connect
+    @digital_auxport_io.expects.write_digital('DIO3', 0).returns(true)
+
+    @minilab.write_digital('DIO3', 0)
+  end
+
+  should "use the digital port object when the pin is a numbered pin for read_digital" do
+    connect
+    @digital_port_io.expects.read_digital(7).returns(1)
+
+    assert_equal 1, @minilab.read_digital(7)
+  end
+
+  should "use the digital port object when the pin is a numbered pin for write_digital" do
+    connect
+    @digital_port_io.expects.write_digital(2, 1).returns(:yourmom)
+
+    assert_equal :yourmom, @minilab.write_digital(2, 1)
+  end
+
+  should "use the digital port object to read a byte from a digital port" do
+    connect
+    @digital_port_io.expects.read_port(:porta).returns(0x22)
+    assert_equal 0x22, @minilab.read_digital_byte(:porta)
+
+    @digital_port_io.expects.read_port(:portcl).returns("monitor")
+    assert_equal "monitor", @minilab.read_digital_byte(:portcl)
+  end
+
+  # Configuration tests
+  should "use the digital port object for configuring a port for input" do
+    connect
+    @digital_port_io.expects.configure_input_port(:portch).returns(true)
+
+    assert @minilab.configure_input_port(:portch)
+  end
+  
+  should "use the digital port object for configuring a port for output" do
+    connect
+    @digital_port_io.expects.configure_output_port(:porta).returns(true)
+
+    assert @minilab.configure_output_port(:porta)
+  end
+
+  private
+  def connect
+    result1 = { :skype => "good" }
+    result2 = { :button => "round" }
+
+    @minilab_hardware.expects.setup_error_handling(DONTPRINT, STOPALL).returns(result1)
+    @result_verifier.expects.verify(result1, "setup_error_handling")
+
+    @minilab_hardware.expects.declare_revision(CURRENTREVNUM).returns(result2)
+    @result_verifier.expects.verify(result2, "declare_revision")
+
+    ports = [:porta, :portb, "thedude", 54]
+    @digital_port_io.expects.get_valid_ports().returns(ports)
+    ports.each do |port|
+      @digital_port_io.expects.configure_input_port(port)
+    end
+
+    @minilab.connect
+  end
+
+  def assert_not_connected_error
+    error = "Cannot use any minilab methods without calling 'connect' first."
+    assert_error(RuntimeError, error) { yield }
+  end
+
+end

data/test/unit/result_verifier_test.rb

@@ -0,0 +1,33 @@
+require File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
+require 'result_verifier'
+
+class ResultVerifierTest < Test::Unit::TestCase
+  def setup
+    mox = create_mocks :minilab_hardware
+    @target = ResultVerifier.new(mox)
+  end
+
+  should "return true when there is no error and not consult the hardware" do
+    result = { :value => 2 }
+
+    assert_equal true, @target.verify(result)
+  end
+
+  should "raise an exception when there is an error" do
+    result = { :error => 1 }
+    @minilab_hardware.expect.get_error_string(1).returns("kaboom")
+    assert_error(RuntimeError, /kaboom/) { @target.verify(result) }
+
+
+    result = { :error => 2 }
+    @minilab_hardware.expect.get_error_string(2).returns("burn")
+    assert_error(RuntimeError, /burn/) { @target.verify(result) }
+  end
+
+  should "include the custom message passed in the exception that is raised" do
+    result = { :error => 1 }
+    @minilab_hardware.expect.get_error_string(1).returns("oy")
+
+    assert_error(RuntimeError, /argh/) { @target.verify(result, "argh") }
+  end
+end

data/vendor/behaviors/lib/behaviors.rb

@@ -0,0 +1,50 @@
+=begin rdoc
+= Usage
+Behaviors provides a single method: should.
+
+Your test classes should <tt>extend Behaviors</tt>. 
+  
+Instead of naming test methods like:
+
+ def test_something
+ end
+
+You declare test methods like:
+
+ should "perform action" do
+ end
+
+You also have the ability to declare flunking test methods as a way
+to describe future tests:
+
+ should "perform other action"
+
+= Motivation
+Test methods typically focus on the name of the method under test instead of its behavior.
+
+Creating test methods with <tt>should</tt> statements focuses on the behaviors of an object.
+This enhances the TDD experience by provoking the developer to think about the role of the object under test.
+
+Writing the tests first to declare an object's behaviors and then implementing those
+behaviors through object methods produces the most value.
+Using this behavior-driven approach prevents the dangers associated with assuming a one-to-one mapping of method names to 
+test method names.
+
+For a more complete BDD framework, try RSpec http://rspec.rubyforge.org/
+  
+= Rake tasks
+
+Behaviors includes a pair of Rake tasks, <tt>behaviors</tt> and <tt>behaviors_html</tt>.  These tasks will output to the
+console or an html file in the <tt>doc</tt> directory with a list all of your <tt>should</tt> tests.
+Use these tasks to summarize the behavior of your project.
+=end
+module Behaviors
+  def should(behave,&block)
+    mname = "test_should_#{behave}"
+    if block
+      define_method mname, &block
+    else
+      puts ">>> UNIMPLEMENTED CASE: #{name.sub(/Test$/,'')} should #{behave}"
+    end
+  end
+end