Hugh Sasse Staff Elec Eng <hgs / dmu.ac.uk> writes:

> Has anyone written any English docs on getting started with RubyUnit?
> I expaect there will be lots of information in Dave and Andy's book, 
> but in the meantime I cannot find much to give me the basic concepts
> on how to use this.  I had a search with Google for information but
> didn't see much.

Sorry - we don't have a chapter on it (umm... maybe we should have)
but it's pretty straightforward.

A basic recipe is:


- require 'runit/testcase'  and 'runit/cui/testrunner'

- Write your tests in a separate class which is a subclass of  
  RUNIT::TestCase.

- write each test (or group of tests) in a method whose name starts
  'test_'

- Run the tests with a line like:

     RUNIT::CUI::TestRunner.run(<classname>.suite)

  where classname is hte name of your testing class.


Within each test, use the 'assert' methods to perform a test:

   assert(boolean, [ optional message])
   assert_equal(expected, actual [, msg])
   assert_equal_float(expected, actual, e, message="")
   assert_same(expected, actual, message="")  # uses equal?
   assert_nil(obj, message="")
   assert_not_nil(obj, message="")
   assert_respond_to(method, obj, message="")
   assert_kind_of(c, obj, message="")
   assert_instance_of(c, obj, message="")
   assert_match(str, re, message="")
   assert_exception(exception, message="")  {block}
   assert_no_exception(*arg) {block}


Then, you can also write two instance methods to setup the environment 
for each test, and to tear it down afterwards (setup and teardown
respectively).


As an example, here's some of the code we use to test class Array:


class TestArray < Rubicon::TestCase

  def test_00_new
    a = Array.new()
    assert_instance_of(Array, a)
    assert_equal(0, a.length)
    assert_nil(a[0])
  end

  def test_01_square_brackets
    a = Array[ 5, 4, 3, 2, 1 ]
    assert_instance_of(Array, a)
    assert_equal(5, a.length)
    5.times { |i| assert_equal(5-i, a[i]) }
    assert_nil(a[6])
  end

  def test_AND # '&'
    assert_equal([1, 3], [ 1, 1, 3, 5 ] & [ 1, 2, 3 ])
    assert_equal([],     [ 1, 1, 3, 5 ] & [ ])
    assert_equal([],     [  ]           & [ 1, 2, 3 ])
    assert_equal([],     [ 1, 2, 3 ]    & [ 4, 5, 6 ])
  end

  def test_MUL # '*'
    assert_equal([], []*3)
    assert_equal([1, 1, 1], [1]*3)
    assert_equal([1, 2, 1, 2, 1, 2], [1, 2]*3)
    assert_equal([], [1, 2, 3] * 0)
    assert_exception(ArgumentError) { [1, 2]*(-3) }

    assert_equal('1-2-3-4-5', [1, 2, 3, 4, 5] * '-')
    assert_equal('12345',     [1, 2, 3, 4, 5] * '')
  end

end


(We actually inherit from our own class, Rubicon, which does more
statistics collection than the basic runit. Rubicon--if the code
crosses it, we get to take over the world)

Hope this helps.


Dave