whitestone 1.0.0

data/test/insulation.rb

@@ -0,0 +1,202 @@
+
+# This file looks at the visibility of classes, modules, methods, constants and
+# instance variables across insulated and non-insulated boundaries.
+#
+# Only T and F assertions are used so that Dfect's behaviour can be tested as
+# well.
+
+module Insulation
+  def answer
+    :foo
+  end
+end
+
+def ruby_version
+  @__ruby_version =
+    case RUBY_VERSION
+    when /^1.8/ then :v18
+    when /^1.9/ then :v19
+    else raise "Unknown version of Ruby: #{RUBY_VERSION}"
+    end
+end
+
+def D18(text, &block)
+  if ruby_version == :v18
+    D text, &block
+  end
+end
+
+def D19(text, &block)
+  if ruby_version == :v19
+    D text, &block
+  end
+end
+
+D "Modules" do
+  D "We can 'extend Insulation' in a non-insulated test" do
+    extend Insulation
+    T { answer() == :foo }
+
+    D "we can use Insulation in a sub-test" do
+    T { answer() == :foo }
+    end
+
+    D! "but we can't use Insulation in an insulated sub-test" do
+      E(NoMethodError) { answer() == :foo }
+    end
+  end
+
+  D "We can still use Insulation in a different (non-insulated) test" do
+    T { answer() == :foo }
+  end
+
+  D! "We CAN'T use Insulation in a different (insulated) test" do
+    E(NoMethodError) { answer() == :foo }
+  end
+
+  D! "If we 'extend Insulation' in an insulated test..." do
+    extend Insulation
+    T { answer() == :foo }
+    D "...we can use Insulation in a sub-test" do
+      T { answer() == :foo }
+    end
+  end
+end  # "Modules"
+
+D "Modules (again)" do
+  E(NoMethodError) { answer() == :foo }   # just checking...
+  D "[nesting]" do
+    D "[nesting]" do
+      D "A module inclusion in a deeply nested test..." do
+        extend Insulation
+      end
+    end
+  end
+  D "...can be used at an outer level" do
+    T { answer() == :foo }
+  end
+  D "(because there was no insulation anywhere)" do end
+end
+
+
+D "Methods" do
+  D "We can define a method (times2) even in a non-insulated test" do
+    def times2(x) x*2 end
+    T { times2(14) == 28 }
+  end
+
+  D "We can use 'times2' in a sibling test..." do
+    T { times2(-5) == -10 }
+    D "...and in a non-insulated sub-test" do
+      T { times2(916) == 1832 }
+    end
+    D! "...but we CAN'T can use 'times2' in an insulated sub-test" do
+      E(NoMethodError) { times2(916) == 1832 }
+    end
+  end
+
+  D "If we set up an insulated test..." do
+    D! "...here..." do
+      D "...and define a method (sum) ..." do
+        def sum(collection) collection.inject(0) { |acc, x| acc + x } end
+      end
+      D "...then we can use the method in a separate test" do
+        T { sum([1,4,2,-3]) == 4 }
+      end
+    end
+    D "...but we CAN'T use the method outside of the insulated environment" do
+      E(NoMethodError) { sum([10,9,8,7]) == 34 }
+    end
+  end
+end  # "Methods"
+
+D "Methods (again)" do
+  D "We CAN'T reuse the times2 and sum in a different test" do
+    E(NoMethodError) { times2(-5) == -10 }
+    E(NoMethodError) { sum([5,100]) == 105 }
+  end
+end
+
+D "Methods (once more)" do
+  D "[nesting]" do
+    D "[nesting]" do
+      D "A method definition in a deeply nested test..." do
+        def empty_string?(str) str.strip.size == 0 end
+      end
+    end
+  end
+  D "...can be used at an outer level" do
+    T { empty_string? "   \t\n " }
+    F { empty_string? " faf fsdf fd " }
+  end
+  D "(because there was no insulation anywhere)" do end
+end
+
+D "Instance variables" do
+  D "@x is defined in one test..." do
+    @x = 6
+  end
+  D "...and is accessible in another..." do
+    T { @x == 6 }
+  end
+  D! "...unless the test is insulated" do
+    F { @x == 6 }
+    D "We can reuse @x in here..." do
+      @x = -1
+      D "(sub-test)" do
+        T { @x == -1 }
+      end
+    end
+  end
+  D "...and it reverts to its previous value outside the insulated area" do
+    T { @x == 6 }
+  end
+end
+
+D "Instance variables (again) " do
+  D! "@y is defined in an insulated test..." do
+    @y = 10
+    D "...and is accessible in a non-insulated subtest" do
+      T { @y == 10 }
+    end
+    D! "...but is not accessible in an insulated subtest" do
+      F { @y == 10 }
+    end
+  end
+  D "...but is not accessible in a sibling test" do
+    F { @y == 10 }
+  end
+end
+
+D "An insulated test..." do
+  D.<< { @a = 32 }
+  D.<  { @z = 99 }
+  D! "...does NOT see an instance variable defined in the setup blocks" do
+    F { @a == 32 }
+    F { @z == 99 }
+  end
+end
+
+# Given that all the above tests pass (in Whitestone and Dfect), here are my
+# conclusions:
+#  * Class and constant definitions are globally accessible and are not affected
+#    by insulation.
+#     - This used to be tested differently in 1.8 and 1.9, but in 1.9.3 the
+#       difference appears to have vanished, so I removed the tests.
+#  * Methods definitions (whether direct or via 'extend Foo') are sealed by
+#    insulation.  Nothing gets in or out.
+#  * The same is true for instance variables.
+#
+# The reason insulation is effective against methods and instance variables is
+# that they rely on the value of _self_ to be resolved.  An insulated
+# environment introduces a new value of _self_.  This is shown in the following
+# (paraphrased) Whitestone code:
+#
+#     def run_test(test)
+#       if test.insulated?
+#         Object.new.instance_eval(&test.block)
+#       else
+#         test.block.call
+#       end
+#     end
+

data/test/whitestone_test.rb

@@ -0,0 +1,616 @@
+
+# Dfect's original test file, with Whitestone's extra assertions added (Eq, Mt, N).
+# 
+# Some of the original tests have been commented out, with an explanation.
+# These will probably be removed later on, but not before committing the reason
+# for their removal.
+#
+# Tests that contain custom error messages have been removed because this
+# facility has been removed from Whitestone.
+
+D "Assertion classes" do
+  D 'T()' do
+    T { true   }
+    T { !false }
+    T { !nil   }
+
+    T { 0 } # zero is true in Ruby! :)
+    T { 1 }
+
+    # The following Dfect behaviour has been removed in Whitestone.
+    # I prefer assertions (of any kind) to return true or false.
+    # Comment kept here in case there's a good reason for the Dfect
+    # behaviour that I'm not currently aware of.
+    #
+    # D 'must return block value' do
+    #   inner = rand()
+    #   outer = T { inner }
+    #   
+    #   T { outer == inner }
+    # end
+  end
+
+  D 'T!()' do
+    T! { !true }
+    T! { false }
+    T! { nil   }
+
+    # See comment above.
+    #
+    # D 'must return block value' do
+    #   inner = nil
+    #   outer = T! { inner }
+    #    
+    #   T { outer == inner }
+    # end
+  end
+
+  D 'T?()' do
+    T { T? { true  } }
+    F { T? { false } }
+    F { T? { nil   } }
+
+    # See above comment.  This one passes anyway, but it's not behaviour I care
+    # to specify.
+    #
+    # D 'must not return block value' do
+    #   inner = rand()
+    #   outer = T? { inner }
+    #    
+    #   F { outer == inner }
+    #   T { outer == true }
+    # end
+  end
+
+  D 'F?()' do
+    T { T? { true  } }
+    F { T? { false } }
+    F { T? { nil   } }
+
+    # See above comment.
+    #
+    # D 'must not return block value' do
+    #   inner = rand()
+    #   outer = F? { inner }
+    #    
+    #   F { outer == inner }
+    #   T { outer == false }
+    # end
+  end
+
+  D 'Eq()' do
+    Eq 5, 5
+    Eq "foo", "foo"
+    Eq [1,2,3,:x], [1,2,3,:x]
+    Eq! "foo", 5
+    Eq! 5, "foo"
+    Eq! [1,2,3,:x], [1,2,3,:z]
+    T { Eq? 5, 5 }
+    F { Eq? 5, 6 }
+  end
+
+  D 'Mt, Mt!, Mt?' do
+    Mt "foo", /foo/
+    Mt /foo/, "fool"        # Order is unimportant.
+    Mt "foo", /./
+    Mt! "foo", /egg/
+    T { Mt? "foo", /o+/ }
+    D "removes color codes before checking match" do
+      require 'col'
+      Mt  Col["foo ", "bar"].fmt('rb,yb'), /foo bar/
+      Mt! Col["foo ", "bar"].fmt('rb,yb'), /foo bat/
+    end
+  end
+
+  D 'N, N!, N?' do
+    N nil
+    N { nil }
+    N! 0
+    N! { 0 }
+    N! false
+    N! { false }
+    T { N? { nil } }
+    F { N? { rand() } }
+  end
+
+  D 'Ko' do
+    Ko "foo",  String
+    Ko "foo",  Object
+    Ko! "foo", Numeric
+    Ko [1,2,3], Enumerable
+    E { Ko String, "foo" }   # wrong order -- expect an error
+  end
+
+  D 'Ft' do
+    Ft  Math::PI, 3.141592    # default tolerance 0.00001
+    Ft! Math::PI, 3.14
+    Ft  Math::PI, 3.14, 0.1   # tolerance for this line is 0.1
+    Ft  Math::PI, 3.14, 0.01
+    Ft  Math::PI, 3.14, 0.001
+    Ft! Math::PI, 3.14, 0.0001
+    D 'test values of massively differing magnitude' do
+      a = 0.000000000837
+      b = 0.0000000004315    # a and b are _not_ "essentially" equal
+      c = 100.000000000837
+      d = 100.0000000004315  # c and d _are_ "essentially" equal
+      Ft! a, b
+      Ft! b, a
+      Ft  c, d
+      Ft  d, c
+    end
+    D 'integer values' do
+      Ft 4,   4
+      Ft 4.0, 4
+      Ft 4,   4.0
+      Ft -13, -13
+      Ft -13.0, -13
+    end
+    D 'zero' do
+      Ft 0,   0
+      Ft 0,   0.0
+      Ft 0.0, 0
+      Ft 0.0, 0.0
+      Ft 0.0, -1.1102230246251565e-16
+      Ft -1.1102230246251565e-16, 0.0
+    end
+    D 'numbers near zero' do
+      Ft  0, 0.00000000000124, 0.0000000001
+      Ft  0, 0.00000000000124, 0.00000000001
+      Ft  0, 0.00000000000124, 0.000000000001
+      Ft  0, 0.00000000000124, 0.0000000000001
+      # The next test fails but I don't know what we really should expect.
+      # Ft! 0, 0.00000000000124, 1e-25
+    end
+    D '(near) equal and negative' do
+      a = -2.0000051298352
+      b = -2.0000051298336
+      Ft a, b, 0.000000001
+      Ft b, a, 0.000000001
+    end
+    D 'tiny numbers' do
+      Ft  1.234567e-50, 1.234568e-50
+      Ft! 1.234567e-50, 1.234567e-51
+    end
+    D 'huge numbers' do
+      Ft  1.234567e50, 1.234568e50
+      Ft! 1.234567e50, 1.234567e51
+    end
+  end
+
+  D 'Id' do
+    Id 5, 5
+    Id (x = "foo"), x
+    Id! "foo", "foo"
+    T { Id? x, x }
+    a = [1,2,3]
+    b = a
+    Id a, b
+    Id a, a
+    Id b, b
+    Id! a, a.dup
+  end
+end  # Assertion methods
+
+def foo
+  raise StandardError, "Error to help test E"
+end
+
+D "Exceptions: E, E!, E?" do
+  D 'E()' do
+    E { foo }
+    E(StandardError) { foo }
+    # There's no longer provisions for specifying an error message.
+    # E(SyntaxError, 'must raise SyntaxError') { raise SyntaxError }
+
+    D 'forbids block to not raise anything' do
+      F { E? {} }
+    end
+
+    # This seems wrong to me.  The block will raise a SyntaxError.  We can't
+    # ignore that; it has to be reported to the user.  Therefore, it can't
+    # appear like that in a unit test.
+    #
+    # This reasoning can be called "Comment E" for reference below.
+    #
+    # D 'forbids block to raise something unexpected' do
+    #   F { E?(ArgumentError) { raise SyntaxError } }
+    # end
+
+    D 'defaults to StandardError when no kinds specified' do
+      E { raise StandardError }
+      E { raise }
+    end
+
+    # See Comment E above.
+    #
+    # D 'does not default to StandardError when kinds are specified' do
+    #   F { E?(SyntaxError) { raise } }
+    # end
+
+    D 'allows nested rescue' do
+      E ArgumentError do
+        begin
+          raise LoadError
+        rescue LoadError
+        end
+
+        raise rescue nil
+
+        raise ArgumentError
+      end
+    end
+  end
+
+  D 'E!()' do
+    # See Comment E above.  Also, I'm not sure E! should actually be able to
+    # specify an Exception type.  Surely the assertion is that it doesn't raise
+    # anything.
+    #
+    # E!(SyntaxError) { raise ArgumentError }
+
+    D 'allows block to not raise anything' do
+      E!() {}
+      E!(ArgumentError) {}
+    end
+
+    # See Comment E.
+    #
+    # D 'allows block to raise something unexpected' do
+    #   T { not E?(ArgumentError) { raise SyntaxError } }
+    # end
+    #  
+    # D 'defaults to StandardError when no kinds specified' do
+    #   E! { raise LoadError }
+    # end
+    #  
+    # D 'does not default to StandardError when kinds are specified' do
+    #   T { not E?(SyntaxError) { raise } }
+    # end
+
+  end
+
+  D 'E?()' do
+    T E?(ArgumentError) { raise ArgumentError }
+    F E?(ArgumentError) { 1 + 1 }
+    # F E?(SyntaxError) { raise ArgumentError }     Comment E
+  end
+end  # "Exceptions: E, E!, E?"
+
+D "Catch: C, C!, C?" do
+  D 'C()' do
+    C(:foo) { throw :foo }
+    C(:foo) { throw :foo }
+
+    D 'forbids block to not throw anything' do
+      F { C?(:bar) {} }
+    end
+
+    D 'forbids block to throw something unexpected' do
+      F { C?(:bar) { throw :foo } }
+    end
+
+    D 'allows nested catch' do
+      C :foo do
+        catch :bar do
+          throw :bar
+        end
+
+        throw :foo
+      end
+    end
+
+    # Like other assertions, C returns true or false.  Whatever value is thrown
+    # is lost.  If I need to test that, I'm happy to do so more directly.
+    #
+    # D 'returns the value thrown along with symbol' do
+    #   inner = rand()
+    #   outer = C(:foo) { throw :foo, inner }
+    #   T { outer == inner }
+    # end
+  end
+
+  D 'Whitestone.caught_value' do
+    def foo
+      throw :abc, 5
+    end
+    def bar
+      throw :abc
+    end
+    C(:abc) { foo }
+    Eq Whitestone.caught_value, 5
+    C(:abc) { bar }
+    Eq Whitestone.caught_value, nil
+    C?(:abc) { foo }
+    Eq Whitestone.caught_value, 5
+    C!(:def) { bar }
+    Eq Whitestone.caught_value, nil
+    C!(:def) { foo }
+    Eq Whitestone.caught_value, nil    # Not updated in this instance.
+  end
+
+  D 'C!()' do
+    C!(:bar) { throw :foo }
+    C!(:bar) { throw :foo }
+
+    D 'allows block to not throw anything' do
+      C!(:bar) {}
+    end
+
+    D 'allows block to throw something unexpected' do
+      T { not C?(:bar) { throw :foo } }
+    end
+
+    D 'allows nested catch' do
+      C! :bar do
+        catch :moz do
+          throw :moz
+        end
+
+        throw :foo
+      end
+    end
+
+    # As per comment above, I have no interest in the value thrown.
+    #
+    # D 'does not return the value thrown along with symbol' do
+    #   inner = rand()
+    #   outer = C!(:foo) { throw :bar, inner }
+    #    
+    #   F { outer == inner }
+    #   T { outer == nil   }
+    # end
+  end
+
+  D 'C?()' do
+    T C?(:foo) { throw :foo }
+    F C?(:bar) { throw :foo }
+  end
+end  # "Catch: C, C!, C?"
+
+D 'D' do
+  D 'D()' do
+    history = []
+
+    D .<< { history << :before_all  }
+    D .<  { history << :before_each }
+    D .>  { history << :after_each  }
+    D .>> { history << :after_all   }
+
+    D 'first nesting' do
+      T { history.select {|x| x == :before_all  }.length == 1 }
+      T { history.select {|x| x == :before_each }.length == 1 }
+      F { history.select {|x| x == :after_each  }.length == 1 }
+      T { history.select {|x| x == :after_all   }.length == 0 }
+    end
+
+    D 'second nesting' do
+      T { history.select {|x| x == :before_all  }.length == 1 }
+      T { history.select {|x| x == :before_each }.length == 2 }
+      T { history.select {|x| x == :after_each  }.length == 1 }
+      T { history.select {|x| x == :after_all   }.length == 0 }
+    end
+
+    D 'third nesting' do
+      T { history.select {|x| x == :before_all  }.length == 1 }
+      T { history.select {|x| x == :before_each }.length == 3 }
+      T { history.select {|x| x == :after_each  }.length == 2 }
+      T { history.select {|x| x == :after_all   }.length == 0 }
+    end
+
+    D 'fourth nesting' do
+      D .<< { history << :nested_before_all  }
+      D .<  { history << :nested_before_each }
+      D .>  { history << :nested_after_each  }
+      D .>> { history << :nested_after_all   }
+
+      nested_before_each = 0
+
+      D .< do
+        # outer values remain the same for this nesting
+        T { history.select {|x| x == :before_all  }.length == 1 }
+        T { history.select {|x| x == :before_each }.length == 4 }
+        T { history.select {|x| x == :after_each  }.length == 3 }
+        T { history.select {|x| x == :after_all   }.length == 0 }
+
+        nested_before_each += 1
+        T { history.select {|x| x == :nested_before_each }.length == nested_before_each }
+      end
+
+      D 'first double-nesting' do
+        T { history.select {|x| x == :nested_before_all  }.length == 1 }
+        T { history.select {|x| x == :nested_before_each }.length == 1 }
+        F { history.select {|x| x == :nested_after_each  }.length == 1 }
+        T { history.select {|x| x == :nested_after_all   }.length == 0 }
+      end
+
+      D 'second double-nesting' do
+        T { history.select {|x| x == :nested_before_all  }.length == 1 }
+        T { history.select {|x| x == :nested_before_each }.length == 2 }
+        T { history.select {|x| x == :nested_after_each  }.length == 1 }
+        T { history.select {|x| x == :nested_after_all   }.length == 0 }
+      end
+
+      D 'third double-nesting' do
+        T { history.select {|x| x == :nested_before_all  }.length == 1 }
+        T { history.select {|x| x == :nested_before_each }.length == 3 }
+        T { history.select {|x| x == :nested_after_each  }.length == 2 }
+        T { history.select {|x| x == :nested_after_all   }.length == 0 }
+      end
+    end
+  end
+
+  D 'D.<() must allow inheritance checking when called without a block' do
+    F { D < Kernel }
+    F { D < Object }
+    F { D < Module }
+    T { D.class == Module }
+
+    c = Class.new { include D }
+    T { c < D }
+  end
+
+  # Whitestone doesn't use YAML output; this test is no longer relevant.
+  #
+  # D 'YAML must be able to serialize a class' do
+  #   T { SyntaxError.to_yaml == "--- SyntaxError\n" }
+  # end
+
+  D! 'insulated root-level describe' do
+    @insulated = :insulated
+    non_closured = :non_closured
+  end
+
+  closured = :closured
+
+  D! 'another insulated root-level describe' do
+    # without insulation, instance variables
+    # from previous root-level describe
+    # environments will spill into this one
+    F { defined? @insulated }
+    F { @insulated == :insulated }
+
+    # however, this insulation must
+    # not prevent closure access to
+    # surrounding local variables
+    T { defined? closured }
+    T { closured == :closured }
+
+    # except local variables defined
+    # within another insulated environment
+    F { defined? non_closured }
+    E(NameError) { non_closured }
+
+    @insulated_again = :insulated_again
+
+    D 'non-insulated nested describe' do
+      D 'inherits instance variables' do
+        T { defined? @insulated_again }
+        T { @insulated_again == :insulated_again }
+      end
+
+      D 'inherits instance methods' do
+        E!(NoMethodError) { instance_level_helper_method }
+        T { instance_level_helper_method == :instance_level_helper_method }
+      end
+
+      D 'inherits class methods' do
+        E!(NoMethodError) { self.class_level_helper_method }
+        T { self.class_level_helper_method == :class_level_helper_method }
+
+        E!(NoMethodError) { class_level_helper_method }
+        T { class_level_helper_method == self.class_level_helper_method }
+      end
+
+      @non_insulated_from_nested = :non_insulated_from_nested
+    end
+
+    D! 'nested but explicitly insulated describe' do
+      D 'does not inherit instance variables' do
+        F { defined? @insulated_again }
+        F { @insulated_again == :insulated_again }
+      end
+
+      D 'does not inherit instance methods' do
+        E(NameError) { instance_level_helper_method }
+      end
+
+      D 'does not inherit class methods' do
+        E(NoMethodError) { self.class_level_helper_method }
+        E(NameError) { class_level_helper_method }
+      end
+
+      @non_insulated_from_nested = 123
+    end
+
+    D 'another non-insulated nested describe' do
+      T { defined? @non_insulated_from_nested }
+      T { @non_insulated_from_nested == :non_insulated_from_nested }
+    end
+
+    def instance_level_helper_method
+      :instance_level_helper_method
+    end
+
+    def self.class_level_helper_method
+      :class_level_helper_method
+    end
+  end
+
+  D 'yet another insulated root-level describe' do
+    F { defined? @insulated_again }
+    F { @insulated_again == :insulated_again }
+
+    F { defined? @non_insulated_from_nested }
+    F { @non_insulated_from_nested == :non_insulated_from_nested }
+  end
+end  # 'D'
+
+D 'Sharing' do
+  S :knowledge do
+    @sharing_is_fun = :share_knowledge
+  end
+
+  S :money do
+    @sharing_is_fun = :share_money
+  end
+
+  D! 'share knowledge' do
+    F { defined? @sharing_is_fun }
+    S :knowledge
+    T { defined? @sharing_is_fun }
+    T { @sharing_is_fun == :share_knowledge }
+
+    F { S? :power }
+    S! :power do
+      @sharing_is_fun = :share_power
+    end
+    T { S? :power }
+  end
+
+  D! 'share money' do
+    F { defined? @sharing_is_fun }
+    S :money
+    T { defined? @sharing_is_fun }
+    T { @sharing_is_fun == :share_money }
+
+    S :power
+    T { defined? @sharing_is_fun }
+    T { @sharing_is_fun == :share_power }
+
+    D! 'share knowledge inside nested but explicitly insulated describe' do
+      F { defined? @sharing_is_fun }
+      S :knowledge
+      T { defined? @sharing_is_fun }
+      T { @sharing_is_fun == :share_knowledge }
+    end
+  end
+
+  D 're-sharing under a previously shared identifier' do
+    E ArgumentError do
+      S :knowledge do
+        @sharing_is_fun = :overwrite_previous_share
+      end
+    end
+
+    F { defined? @sharing_is_fun }
+    F { @sharing_is_fun == :overwrite_previous_share }
+  end
+
+  D 'injecting an unshared code block' do
+    E ArgumentError do
+      S :foobar
+    end
+  end
+end  # 'Sharing'
+
+#E 'injecting shared block outside of a test' do
+E {
+  # It's an error to inject a shared block outside of a test.
+  S :knowledge
+}
+
+  # Cancelling this test because it prevents others in the directory from being run.
+xD 'stoping #run' do
+  Whitestone.stop
+  raise 'this must not be reached!'
+end