whitestone 1.0.0

data/etc/aliases

@@ -0,0 +1,5 @@
+alias d='cat debug.log'
+alias test='ruby -rubygems -Ilib -r whitestone/auto test/whitestone_test.rb'
+alias g='grep -nR lib -e'
+alias t='ctags -R lib'
+alias local_whitestone='ruby -Ilib -rubygems -I../col/lib bin/whitestone'

data/etc/examples/example_1.rb

@@ -0,0 +1,51 @@
+
+  # This example runs some tests against the Date class.  All of them pass.
+  # The Date class is large and complex; this barely scratches the surface.
+
+  require 'date'
+
+  D "Date" do
+
+    D.< {                                 # setup for each block
+      @d = Date.new(1972, 5, 13)
+    }
+
+    D "#to_s" do
+      Eq @d.to_s, "1972-05-13"
+    end
+
+    D "#next" do
+      end_of_april = Date.new(2010, 4, 30)
+      start_of_may = Date.new(2010, 5, 1)
+      T { end_of_april.next == start_of_may }
+    end
+
+    D "day, month, year, week, day-of-year, etc." do
+
+      D.< { :extra_setup_for_these_three_blocks_if_required }
+
+      D "civil" do
+        Eq @d.year,   1972
+        Eq @d.month,  5
+        Eq @d.day,    13
+      end
+      D "commercial" do
+        Eq @d.cwyear, 1972
+        Eq @d.cweek,  19       # Commercial week-of-year
+        Eq @d.cwday,  6        # Commercial day-of-week (6 = Sat)
+      end
+      D "ordinal" do
+        Eq @d.yday,   134      # 134th day of the year
+      end
+    end
+
+    D "#leap?" do
+      [1984, 2000, 2400].each do |year|
+        T { Date.new(year, 6, 27).leap? }
+      end
+      [1900, 2007, 2100, 2401].each do |year|
+        F { Date.new(year, 12, 3).leap? }
+      end
+    end
+
+  end

data/etc/examples/example_2.rb

@@ -0,0 +1,51 @@
+
+  # This example is the same as Example 1, except that some bugs have
+  # been introduced into the test code so that some assertions will fail.
+
+  require 'date'
+
+  D "Date" do
+
+    D.< {                                 # setup for each block
+      @d = Date.new(1972, 5, 13)
+    }
+
+    D "#to_s" do
+      Eq @d.to_s, "1972-5-13"
+    end
+
+    D "#next" do
+      end_of_april = Date.new(2010, 4, 30)
+      start_of_may = Date.new(2010, 6, 1)
+      T { end_of_april.next == start_of_may }
+    end
+
+    D "day, month, year, week, day-of-year, etc." do
+
+      D.< { :extra_setup_for_these_three_blocks_if_required }
+
+      D "civil" do
+        Eq @d.year,   1972
+        Eq @d.month,  5
+        Eq @d.day,    13
+      end
+      D "commercial" do
+        Eq @d.cwyear, 1972
+        Eq @d.cweek,  13       # Commercial week-of-year
+        Eq @d.cwday,  6        # Commercial day-of-week (6 = Sat)
+      end
+      D "ordinal" do
+        Eq @d.day_of_year,  134      # 134th day of the year
+      end
+    end
+
+    D "#leap?" do
+      [1984, 2000, 2400].each do |year|
+        T { Date.new(year, 6, 27).leap? }
+      end
+      [1900, 2007, 2100, 2401].each do |year|
+        F { Date.new(year, 12, 3).leap? }
+      end
+    end
+
+  end

data/etc/extra_tests/basic.rb

@@ -0,0 +1,56 @@
+
+D "Whitestone.action" do
+  T { Whitestone.action :Eq, :query, 4, 4 }
+  T { Whitestone.action :T,  :query, :foo }
+  T { Whitestone.action(:T,  :query) { :foo } }
+end
+
+def this_method_will_raise_an_error
+  raise StandardError, "Sample error"
+end
+
+def this_one_wont
+  :foo
+end
+
+def throws_foo
+  throw :foo
+end
+
+def doesnt_throw_foo
+  :noop
+end
+
+def specific_error(sym)
+  case sym
+  when :type  then raise TypeError
+  when :run   then raise RuntimeError
+  when :range then raise RangeError
+  when :io    then raise IOError
+  else             raise ArgumentError
+  end
+end
+
+D "Basic tests" do
+  x = 2 + 2
+  T  { x == 4 }
+  T! { x == 5 }
+  F  { x == 5 }
+  F! { x == 4 }
+  N  { "foo".index("z") }
+  N! { "foo".index("o") }
+  Eq  x, 4
+  Eq! x, 5
+  Mt  /(an){2}/, "banana"
+  Mt! /(an){3}/, "banana"
+  E  { this_method_will_raise_an_error }
+  E! { this_one_wont }
+  E!(RangeError) { this_one_wont }
+  E()                      { specific_error(:run) }
+  E(RuntimeError)          { specific_error(:run) }
+  E(RuntimeError, IOError) { specific_error(:run) }
+  C(:foo)  { throws_foo }
+  C!(:foo) { doesnt_throw_foo }
+
+  E!() { specific_error(:io) }
+end

data/etc/extra_tests/error_should_not_also_fail.rb

@@ -0,0 +1,17 @@
+
+def some_method(n)
+  raise ArgumentError unless n > 0
+  n
+end
+
+D "An error should not also fail" do
+  ## The following call should result in ERROR and not an additional FAIL.
+  ## (This is therefore not a unit test, really; it's designed to error out...)
+  T { this_method_does_not_exist(:foo) }
+
+  ## This test works
+  Eq some_method(5), 5
+
+  ## This test errors out
+  Eq some_method(-5), -5
+end

data/etc/extra_tests/output_examples.rb

@@ -0,0 +1,108 @@
+
+# The examples here are designed to demonstrate that all the different ways of
+# failing (T, F, N, Eq, Mt, E, C) produce good output.
+#
+# Some of the tests will pass; some will fail; some will raise an error.
+#
+# The output doesn't make pretty reading, but it's a way to look for poor
+# formatting or inconsistent colour or less-than-helpful error messages.
+
+load "#{Dir.pwd}/etc/extra_tests/output_examples_code.rb"
+
+D 'Vanilla assertion failure' do
+  T { prime? 64 }
+end
+
+D "Attempt to open file that doesn't exist" do
+  T { count_lines_in_file("fdsjhfaksljdfhakljshdf.txt") == 492 }
+end
+
+D 'Expected error to be raised but it didn\'t happen (default: StandardError)' do
+  E { prime? 13 }
+end
+
+D "Expected error to be raised but it didn't happen (specify errors)" do
+  E(ArgumentError, NameError) { prime? 99 }
+end
+
+D "Expect NameError to be raised but it's not NameError; it's Errno::ENOENT" do
+  E(NameError) { count_lines_in_file("fdsjhfakslljshdf.txt") }
+end
+
+D 'Expect no error to occur, but one does' do
+  E! { count_lines_in_file("fdsjhfaksljdfhakljshdf.txt") }
+end
+
+D 'Failure to catch appropriate symbol' do
+  C(:something) { Dir.entries('.') }
+end
+
+D 'Expected :even not to be thrown but it was' do
+  C!(:even) { even_or_odd(12) }
+end
+
+D 'Error raised while trying to catch a symbol' do
+  C(:foo) { count_lines_in_file("fdsjhfakshakljshdf.txt") }
+end
+
+D 'Test prime?' do
+  T { prime? 43 }
+  F { prime? 1 }
+  E { prime? 450 }
+  E { prime? 41.9 }
+  E!{ prime? 35 }
+end
+
+D 'Test even_or_odd' do
+  C(:even) { even_or_odd(148) }
+  C(:odd)  { even_or_odd(9313) }
+end
+
+D 'Straightforward equality failure (positive)' do
+  array = (1...10).to_a
+  Eq array.size, 10
+end
+
+D 'Straightforward equality failure (negative)' do
+  Eq! "\n\t text   \r \n".strip, "text"
+end
+
+D 'Test simple_html; demonstrates string difference' do
+  text = "I _must_ go down to the *seas* again\nTo the @lonely@ sea and the sky"
+  Eq simple_html(text), 
+    "<p>I <em>must</em> go down to <strong>seas</strong> again\nTo the " +
+    "<code>lonely</code> sea and the skies</p>"
+end
+
+D 'Regular expression matching (positive)' do
+  Mt "Smith, John: (02) 9481 1111", /^[A-z0-9]+$/
+end
+
+D 'Regular expression matching (negative)' do
+  Mt! "Doe, Jane: (07) 131 008", /Jane/
+end
+
+D 'Expecting something to be nil' do
+  N [25, 32, 7, 51].find { |n| prime? n }
+end
+
+D 'Expecting something not to be nil' do
+  N! { "foo".index('t') }
+end
+
+D 'Identity (positive)' do
+  Id "foo", "foo"
+end
+
+D 'Identity (negative)' do
+  array = (1..10).to_a
+  Id! array, array
+end
+
+D 'Float equality (positive)' do
+  Ft 3.14, Math::PI
+end
+
+D 'Float equality (negative)' do
+  Ft! 3.141592654, Math::PI
+end

data/etc/extra_tests/output_examples_code.rb

@@ -0,0 +1,38 @@
+
+# Used to test 'catch'
+def even_or_odd(n)
+  if n % 2 == 1
+    throw :odd
+  else
+    throw :even
+  end
+end
+
+# Used to generate errors (file not found).
+def count_lines_in_file(path)
+  File.readlines(path).size
+end
+
+# Used for assertions and error raising.
+def prime?(n)
+  unless (1..100).include? n
+    raise ArgumentError, "Argument to prime? must be in range (1..100): #{n}"
+  end
+  unless Integer === n
+    raise ArgumentError, "Argument to prime? must be an integer: #{n}"
+  end
+  return false if n == 1
+  (2..Math.sqrt(n).to_i).map { |i| n % i }.all? { |rem| rem != 0 }
+end
+
+  # Used to test string equality and demonstrate string difference.
+  # Surround with <p>, implement _word_, *word* and @word@.  Remove newlines.
+def simple_html(string)
+  tag = lambda { |str, t| "<#{t}>#{str}</#{t}>" }
+  html = string.
+    gsub(/_(\w+)_/)   { tag[$1, :em]     }.
+    gsub(/\*(\w+)\*/) { tag[$1, :strong] }.
+    gsub(/@(\w+)@/)   { tag[$1, :code]   }.
+    gsub(/\r?\n/, ' ')
+  tag[html, :p]
+end

data/etc/extra_tests/raise.rb

@@ -0,0 +1,4 @@
+
+D "Raise error during a test" do
+  raise "Foo"
+end

data/etc/extra_tests/realistic_example.rb

@@ -0,0 +1,94 @@
+
+# This file contains a realistic example of unit testing using whitestone.
+# The code contains bugs which the tests reveal.
+
+# - something with a complex #inspect and/or #to_s (or perhaps #html)
+# - something that takes direct input and gives direct output
+#   (i.e. no need for reading file or interacting with other objects)
+# - something involving some parsing, like RGeom's types
+# - something involving a data store (index), especially if it means
+#   that setup is required before the tests
+# - add_xxx(...)
+# - maybe take a test from an existing project (RubyGems?) and convert
+#   it to whitestone
+# - RGeom::Label ?
+# - RGeom::Point, modified to store points like :A itself ?
+#   - and RGeom::Vertex to boot?
+# - something that takes a nested data structure (arrays inside hashes
+#   inside...) and generates meaningful summary data
+# - look at existing unit testing tutorials on the net
+#   - found nothing
+# - something in standard library ?
+#   - extend Date with some Duration-type methods ?
+# - some extensions to core classes, taken from 'extensions' ?
+
+  # p1 = Point.new(5, -2)
+  # p2 = Point.polar(11, 30)
+  # Point[:A] = p1
+  # Point[:B] = p2
+  # Point[:A]         # -> p1
+class Point
+  @@index = Hash.new
+  def initialize(x, y)
+    @x, @y = x, y
+  end
+  def Point.cartesian(x, y)
+    Point.new(x, y)
+  end
+  def Point.polar(r, th)
+    Point.new(r * Math.cos(th), r * Math.sin(th))
+  end
+  def Point.[](symbol)
+    @@index[symbol]
+  end
+  def Point.[]=(symbol, point)
+    @@index[symbol] = point
+  end
+  def polar
+    r = Math.sqrt(x**2 + y**2)
+    th = Math.atan2(y, x)
+    [r, th]
+  end
+end
+
+
+# 
+# Simple markup function to turn formatted text into HTML:
+# * Implement _word_, *word* and @word@ (em, strong and code, respectively);
+# * Surround paragraphs with <p> tags;
+# * Turn single newlines into spaces.
+# 
+def simple_markup(string)
+  tag = lambda { |str, t| "<#{t}>#{str}</#{t}>" }
+  html = string.
+    gsub(/_(\w+)_/)     { tag[$1, :em]     }.
+    gsub(/\*(\W+)\*/)   { tag[$1, :strong] }.
+    gsub(/@(\w+)@/)     { tag[$1, :code]   }.
+    gsub(/(.+?)\n{2,}/) { tag[$1, :p]      }. 
+    gsub(/\n/, ' ')
+end
+
+D "simple_markup" do
+  D "breaks text into paragraphs" do
+    Eq simple_markup("abc"),                     "<p>abc</p>"
+    Eq simple_markup("abc\n\ndef"),              "<p>abc</p><p>def</p>"
+    Eq simple_markup("abc\n\ndef\n\n\n\nghi\n"), "<p>abc</p><p>def</p><p>ghi</p>"
+  end
+  D "replaces single newlines with a space" do
+    Eq simple_markup("abc\ndef"),      "<p>abc xyz</p>"
+    Eq simple_markup("abc\ndef\nghi"), "<p>abc xyz ghi</p>"
+  end
+  D "handles mixed paragraphs and single newlines correctly" do
+    text = "Once upon a time\nIn a land far away\n\n" \
+         + "A frog named Kermit\n\nDecared he was here to stay"
+    html = "<p>Once upon a time In a land far away</p>" \
+         + "<p>A frog named Kermit Decared he was here to stay</p>"
+    Eq simple_markup(text), html
+  end
+  D "handles _words_" do
+    Eq simple_markup("One _two_ _three_"), "<p>One <em>two</em> <em>three</em></p>"
+  end
+  D "handles *words*" do
+    Eq simple_markup("One *fine* day"), "<p>One <strong>fine</strong> day</p>"
+  end
+end

data/etc/extra_tests/specification_error.rb

@@ -0,0 +1,8 @@
+
+D "Incorrect use of assertions" do
+  T { 1 + 1 == 2 }     # this is fine
+  T(5) { 6 }           # can't give argument _and_ block
+  Eq 1, 2, 3           # must be two values
+  Eq 1                 # must be two values
+  Eq() { :foo }        # block not allowed
+end

data/etc/extra_tests/stop.rb

@@ -0,0 +1,16 @@
+D "Whitestone.stop" do
+  D "Benign first test" do
+    T { 1 + 1 == 2 }
+  end
+  D "Here we go" do
+    if defined? Whitestone
+      Whitestone.stop
+    elsif defined? Dfect
+      Dfect.stop
+    end
+    raise "Must not get here"
+  end
+  D "Must not get here" do
+    raise "Must not get here"
+  end
+end