minilab 1.1.0-x86-mswin32-60

data/test/unit/minilab_context_test.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+
+class MinilabContextTest < Test::Unit::TestCase
+  def setup
+    @target = MinilabContext.new
+  end
+
+  should "build minilab context" do
+    context = nil
+    assert_nothing_raised "should build without error" do
+      context = @target.build
+    end
+    assert_not_nil context, "should have gotten a 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 "give the same context when built more than once" do
+    assert_same @target.build, @target.build, "not the same context object"
+  end
+end

data/test/unit/minilab_hardware_test.rb

@@ -0,0 +1,33 @@
+require File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
+
+# Not many tests for this class, since there isn't much behavior outside of
+# calling into the minilab library. I could probably figure out another way
+# to unit test those calls, but I don't believe there would be much value
+# in brittle tests for code that is already covered by system tests.
+class MinilabHardwareTest < Test::Unit::TestCase
+  include MinilabConstants
+
+  def setup
+    @target = MinilabHardware.new
+  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,115 @@
+require File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
+
+class MinilabTest < Test::Unit::TestCase
+  include MinilabConstants
+
+  def setup
+    mox = create_mocks(:minilab_wrapper, :analog_io, :digital_auxport_io, :digital_port_io, :connection_state)
+    @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 instance"
+  end
+
+  should "connect to the hardware, setup the error handling, declare the library revision, and setup the db37 ports for input" do
+    @minilab_wrapper.expects.setup_error_handling(DONTPRINT, STOPALL)
+    @minilab_wrapper.expects.declare_revision(CURRENTREVNUM)
+    @connection_state.expects.connected=(true)
+
+    DigitalConfiguration::PORTS.each do |port|
+      @connection_state.expects.connected?.returns true
+      @digital_port_io.expects.configure_input_port(port)
+    end
+
+    @minilab.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
+    @connection_state.expects.connected?.returns true
+    @analog_io.expects.read_analog(4).returns(1.1)
+
+    assert_equal 1.1, @minilab.read_analog(4)
+  end
+  
+  should "write analog output" do
+    @connection_state.expects.connected?.returns true
+    @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
+    @connection_state.expects.connected?.returns true
+    @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
+    @connection_state.expects.connected?.returns true
+    @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
+    @connection_state.expects.connected?.returns true
+    @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
+    @connection_state.expects.connected?.returns true
+    @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
+    @connection_state.expects.connected?.returns true
+    @digital_port_io.expects.read_port(:porta).returns(0x22)
+    assert_equal 0x22, @minilab.read_digital_byte(:porta)
+  end
+
+  # Configuration tests
+  should "use the digital port object for configuring a port for input" do
+    @connection_state.expects.connected?.returns true
+    @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
+    @connection_state.expects.connected?.returns true
+    @digital_port_io.expects.configure_output_port(:porta).returns(true)
+
+    assert @minilab.configure_output_port(:porta)
+  end
+
+  private
+  def assert_not_connected_error
+    @connection_state.expects.connected?.returns false
+    error = "Cannot use any minilab methods without calling 'connect' first."
+    assert_error(RuntimeError, error) { yield }
+  end
+end

data/test/unit/minilab_wrapper_test.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
+
+class MinilabWrapperTest < Test::Unit::TestCase
+  def setup
+    mox = create_mocks(:minilab_hardware)
+    @target = MinilabWrapper.new(mox)
+  end
+
+  should "call forward methods to the hardware and give the result" do
+    @minilab_hardware.expects.razzle(1, 2, "three").returns({ :value => 5 })
+    assert_equal 5, @target.razzle(1, 2, "three")
+
+    @minilab_hardware.expects.dazzle.returns({ :value => :whatever })
+    assert_equal :whatever, @target.dazzle
+  end
+
+  should "raise an error when there is a hardware error" do
+    @minilab_hardware.expects.bang(1, 2).returns({ :error => 4 })
+    @minilab_hardware.expects.get_error_string(4).returns "Righteous error"
+    assert_error RuntimeError, "Command [bang([1, 2])] caused a hardware error: Righteous error" do
+      @target.bang(1, 2)
+    end
+  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

data/vendor/behaviors/tasks/behaviors_tasks.rake

@@ -0,0 +1,140 @@
+desc "List behavioral definitions for the classes under test (use for=<term> also)"
+task :behaviors do
+  specifications.each do |spec|
+    puts "#{spec.name} should:\n"
+    spec.requirements.each do |req|
+      puts " - #{req}"
+    end
+  end
+end
+
+desc "List behavioral definitions for the classes under test (HTML output)"
+task :behaviors_html do
+  require 'erb'
+  txt =<<-EOS 
+  <html>
+  <head>
+  <style>
+
+  div.title
+  {
+    width: 600px;
+    font: bold 14pt trebuchet ms;
+  }
+
+  div.specification 
+  {
+    font: bold 12pt trebuchet ms;
+    border: solid 1px black;
+    width: 600px;
+    padding: 5px;
+    margin: 5px;
+  }
+
+  ul.requirements
+  {
+    font: normal 11pt verdana;
+    padding-left: 0;
+    margin-left: 0;
+    border-bottom: 1px solid gray;
+    width: 600px;
+  }
+
+  ul.requirements li
+  {
+    list-style: none;
+    margin: 0;
+    padding: 0.25em;
+    border-top: 1px solid gray;
+  }
+  </style>
+  </head>
+  <body>
+  <div class="title">Specifications for <%= title %></div>
+  <% specifications.each do |spec| %>
+  <div class="specification">
+  <%= spec.name %> should: 
+  <ul class="requirements">
+  <% spec.requirements.each do |req| %>
+  <li><%= req %></li>
+  <% end %>
+  </ul>
+  </div>
+  <% end %>
+  </body>
+  </html>
+  EOS
+  output_dir = File.expand_path("#{APP_ROOT}/doc")
+  mkdir_p output_dir
+  output_filename = output_dir + "/behaviors.html"
+  File.open(output_filename,"w") do |f|
+    f.write ERB.new(txt).result(binding)
+  end
+  puts "(Wrote #{output_filename})"
+end
+
+def title
+  File.basename(File.expand_path(APP_ROOT))
+end
+
+def specifications
+  test_files.map do |file|
+    spec = OpenStruct.new
+    m = %r".*/([^/].*)_test.rb".match(file)
+    class_name = titleize(m[1]) if m[1]
+    spec.name = class_name
+    spec.requirements = []
+    File::readlines(file).each do |line| 
+      if line =~ /^\s*should\s+\(?\s*["'](.*)["']/
+        spec.requirements << $1
+      end
+    end
+    spec
+  end
+end
+
+def test_files
+  test_list = FileList["#{APP_ROOT}/test/**/*_test.rb"]
+  if ENV['for'] 
+    test_list = test_list.grep(/#{ENV['for']}/i)
+  end
+  test_list
+end  
+
+
+############################################################
+# STOLEN FROM inflector.rb
+############################################################
+#--
+# Copyright (c) 2005 David Heinemeier Hansson
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+def titleize(word)
+  humanize(underscore(word)).gsub(/\b([a-z])/) { $1.capitalize }
+end    
+
+def underscore(camel_cased_word)    camel_cased_word.to_s.gsub(/::/, '/').
+  gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
+end
+
+def humanize(lower_case_and_underscored_word)
+  lower_case_and_underscored_word.to_s.gsub(/_id$/, "").gsub(/_/, " ").capitalize
+end

data/vendor/behaviors/test/behaviors_tasks_test.rb

@@ -0,0 +1,71 @@
+require 'test/unit'
+
+APP_ROOT = File.expand_path(File.dirname(__FILE__) + '/../')
+
+class BehaviorsTasksTest < Test::Unit::TestCase
+
+  def setup
+    here = File.expand_path(File.dirname(__FILE__))
+    cmd = RUBY_PLATFORM[/mswin/] ? 'rake.cmd' : 'rake'
+    @base_cmd = "#{cmd} -f \"#{here}/tasks_test/Rakefile\" "    
+  end 
+
+  #
+  # HELPERS
+  #
+  def run_behaviors_task
+    run_cmd "behaviors"
+  end
+
+  def run_behaviors_html_task
+    run_cmd "behaviors_html"
+  end
+
+  def run_cmd(cmd)
+    @report = %x[ #{@base_cmd} #{cmd} ]
+  end
+
+  def see_html_task_output_message
+    @html_output_filename = "#{APP_ROOT}/test/tasks_test/doc/behaviors.html"
+    assert_match /Wrote #{@html_output_filename}/, @report
+  end
+
+  def see_that_html_report_file_exits
+    assert File.exists?(@html_output_filename), "html output file should exist"
+  end
+
+  def html_report_file_should_contain(user_behaviors)
+    file_contents = File.read(@html_output_filename)
+    user_behaviors.each do |line|
+      assert_match /#{line}/, file_contents
+    end
+  end
+
+  #
+  # TESTS
+  #
+  def test_that_behaviors_tasks_should_list_behavioral_definitions_for_the_classes_under_test
+    run_behaviors_task
+    user_behaviors = [
+    "User should:",
+    " - be able set user name and age during construction",
+    " - be able to get user name and age",
+    " - be able to ask if a user is an adult"
+    ]
+    assert_match /#{user_behaviors.join("\n")}/, @report
+  end
+
+  def test_that_behaviors_tasks_should_list_behavioral_definitions_for_the_classes_under_test_in_html_output
+    run_behaviors_html_task
+    see_html_task_output_message
+    see_that_html_report_file_exits
+    user_behaviors = [
+      "User should:",
+      "be able set user name and age during construction",
+      "be able to get user name and age",
+      "be able to ask if a user is an adult"
+    ]
+    html_report_file_should_contain user_behaviors
+  end
+
+end