facets 2.0.2 → 2.0.3

data/test/unit/test_ostruct.rb

@@ -1,130 +1,177 @@
-  #  _____         _
-  # |_   _|__  ___| |_
-  #   | |/ _ \/ __| __|
-  #   | |  __/\__ \ |
-  #   |_|\___||___/\__|
-  #
-  # for lib/facets/ostruct.rb
-  #
-  # Extracted Mon Sep 03 16:23:07 -0700 2007
-  # w/ Test Extraction Ratchet
-  #
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |
+#   |_|\___||___/\__|
+#
+# for lib/facets/ostruct.rb
 
- require 'facets/ostruct.rb'
+require 'facets/ostruct.rb'
+require 'test/unit'
 
+class TestOpenStruct < Test::Unit::TestCase
 
+  def setup
+    @o = OpenStruct.new(:q => 1)
+  end
 
-  require 'test/unit'
+  def test_update
+    o = OpenStruct.new( { :a => 1 } )
+    h = { :b => 2 }
+    assert_nothing_raised { o.__update__( h ) }
+    assert_equal( 2, o.b )
+  end
 
-  class TestOpenStruct < Test::Unit::TestCase
+  def test_merge_1
+    o = OpenStruct.new( { :a => 1 } )
+    h = { :b => 2 }
+    q = o.__merge__( h )
+    assert_equal( 1, q.a )
+    assert_equal( 2, q.b )
+  end
 
-    def setup
-      @o = OpenStruct.new(:q => 1)
-    end
+  def test_merge_2
+    o1 = OpenStruct.new( { :a => 1 } )
+    o2 = OpenStruct.new( { :b => 2 } )
+    q = o1.__merge__( o2 )
+    assert_equal( 1, q.a )
+    assert_equal( 2, q.b )
+  end
 
-    def test_update
-      o = OpenStruct.new( { :a => 1 } )
-      h = { :b => 2 }
-      assert_nothing_raised { o.__update__( h ) }
-      assert_equal( 2, o.b )
-    end
+  def test_store
+    @o.instance_delegate.store(:a,1)
+    assert_equal( 1, @o.a )
+  end
 
-    def test_merge_1
-      o = OpenStruct.new( { :a => 1 } )
-      h = { :b => 2 }
-      q = o.__merge__( h )
-      assert_equal( 1, q.a )
-      assert_equal( 2, q.b )
-    end
+  def test_update
+    @o.instance_delegate.update(:a=>1)
+    assert_equal( 1, @o.a )
+  end
 
-    def test_merge_2
-      o1 = OpenStruct.new( { :a => 1 } )
-      o2 = OpenStruct.new( { :b => 2 } )
-      q = o1.__merge__( o2 )
-      assert_equal( 1, q.a )
-      assert_equal( 2, q.b )
-    end
+  def test_op_fetch
+    o = OpenStruct.new( { :a => 1 } )
+    assert_equal( 1, o[:a] )
+  end
 
-    def test_store
-      @o.instance_delegate.store(:a,1)
-      assert_equal( 1, @o.a )
-    end
+  def test_op_store
+    o = OpenStruct.new( { :a => 1 } )
+    assert_nothing_raised { o[:b] = 2 }
+    assert_equal( 2, o.b )
+  end
 
-    def test_update
-      @o.instance_delegate.update(:a=>1)
-      assert_equal( 1, @o.a )
-    end
+  def test_update
+    o = OpenStruct.new( { :a => 1 } )
+    h = { :b => 2 }
+    assert_nothing_raised { o.__update__( h ) }
+    assert_equal( 2, o.b )
+  end
 
-    def test_op_fetch
-      o = OpenStruct.new( { :a => 1 } )
-      assert_equal( 1, o[:a] )
-    end
+  def test_merge_1
+    o = OpenStruct.new( { :a => 1 } )
+    h = { :b => 2 }
+    q = o.__merge__( h )
+    assert_equal( 1, q.a )
+    assert_equal( 2, q.b )
+  end
 
-    def test_op_store
-      o = OpenStruct.new( { :a => 1 } )
-      assert_nothing_raised { o[:b] = 2 }
-      assert_equal( 2, o.b )
-    end
+  def test_merge_2
+    o1 = OpenStruct.new( { :a => 1 } )
+    o2 = OpenStruct.new( { :b => 2 } )
+    q = o1.__merge__( o2 )
+    assert_equal( 1, q.a )
+    assert_equal( 2, q.b )
+  end
 
-    def test_update
-      o = OpenStruct.new( { :a => 1 } )
-      h = { :b => 2 }
-      assert_nothing_raised { o.__update__( h ) }
-      assert_equal( 2, o.b )
-    end
+end
 
-    def test_merge_1
-      o = OpenStruct.new( { :a => 1 } )
-      h = { :b => 2 }
-      q = o.__merge__( h )
-      assert_equal( 1, q.a )
-      assert_equal( 2, q.b )
-    end
+class TestOpenStructInitialize < Test::Unit::TestCase
 
-    def test_merge_2
-      o1 = OpenStruct.new( { :a => 1 } )
-      o2 = OpenStruct.new( { :b => 2 } )
-      q = o1.__merge__( o2 )
-      assert_equal( 1, q.a )
-      assert_equal( 2, q.b )
-    end
+  class Person < OpenStruct; end
 
+  def test_1_old_functionality
+    o = OpenStruct.new
+    assert_nil(o.foo)
+    o.foo = :bar
+    assert_equal(:bar, o.foo)
+    o.delete_field(:foo)
+    assert_nil(o.foo)
+    o1 = OpenStruct.new(:x => 1, :y => 2)
+    assert_equal(1, o1.x)
+    assert_equal(2, o1.y)
+    o2 = OpenStruct.new(:x => 1, :y => 2)
+    assert(o1 == o2)
   end
 
-
-  class TestHashToOpenStruct < Test::Unit::TestCase
-
-    def test_to_ostruct
-      a = { :a => 1, :b => 2, :c => 3 }
-      ao = a.to_ostruct
-      assert_equal( a[:a], ao.a )
-      assert_equal( a[:b], ao.b )
-      assert_equal( a[:c], ao.c )
+  def test_2_new_functionality
+    person = OpenStruct.new do |p|
+      p.name = 'John Smith'
+      p.gender  = :M
+      p.age     = 71
     end
-
-    def test_to_ostruct_recurse
-      a = { :a => 1, :b => 2, :c => { :x => 4 } }
-      ao = a.to_ostruct_recurse
-      assert_equal(  a[:a], ao.a )
-      assert_equal(  a[:b], ao.b )
-      assert_equal(  a[:c][:x], ao.c.x )
+    assert_equal('John Smith', person.name)
+    assert_equal(:M, person.gender)
+    assert_equal(71, person.age)
+    assert_equal(nil, person.address)
+    person = OpenStruct.new(:gender => :M, :age => 71) do |p|
+      p.name = 'John Smith'
     end
+    assert_equal('John Smith', person.name)
+    assert_equal(:M, person.gender)
+    assert_equal(71, person.age)
+    assert_equal(nil, person.address)
+  end
 
-    def test_to_ostruct_recurse_with_recursion
-      a = {}
-      a[:a] = a
-      ao = a.to_ostruct_recurse
-      assert_equal( ao, ao.a )
+  def test_3_subclass
+    person = Person.new do |p|
+      p.name = 'John Smith'
+      p.gender  = :M
+      p.age     = 71
     end
-
-    def test_to_ostruct_advanced
-      h = { 'a' => { 'b' => 1 } }
-      o = h.to_ostruct_recurse( { h['a'] => h['a'] } )
-      assert_equal( 1, o.a['b'] )
-      assert( Hash === o.a )
+    assert_equal('John Smith', person.name)
+    assert_equal(:M, person.gender)
+    assert_equal(71, person.age)
+    assert_equal(nil, person.address)
+    person = Person.new(:gender => :M, :age => 71) do |p|
+      p.name = 'John Smith'
     end
+    assert_equal('John Smith', person.name)
+    assert_equal(:M, person.gender)
+    assert_equal(71, person.age)
+    assert_equal(nil, person.address)
+  end
+end
+
+class TestHashToOpenStruct < Test::Unit::TestCase
+
+  def test_to_ostruct
+    a = { :a => 1, :b => 2, :c => 3 }
+    ao = a.to_ostruct
+    assert_equal( a[:a], ao.a )
+    assert_equal( a[:b], ao.b )
+    assert_equal( a[:c], ao.c )
+  end
+
+  def test_to_ostruct_recurse
+    a = { :a => 1, :b => 2, :c => { :x => 4 } }
+    ao = a.to_ostruct_recurse
+    assert_equal(  a[:a], ao.a )
+    assert_equal(  a[:b], ao.b )
+    assert_equal(  a[:c][:x], ao.c.x )
+  end
 
+  def test_to_ostruct_recurse_with_recursion
+    a = {}
+    a[:a] = a
+    ao = a.to_ostruct_recurse
+    assert_equal( ao, ao.a )
   end
 
+  def test_to_ostruct_advanced
+    h = { 'a' => { 'b' => 1 } }
+    o = h.to_ostruct_recurse( { h['a'] => h['a'] } )
+    assert_equal( 1, o.a['b'] )
+    assert( Hash === o.a )
+  end
 
+end
 

data/test/unit/test_overload.rb

@@ -1,18 +1,11 @@
-  #  _____         _
-  # |_   _|__  ___| |_
-  #   | |/ _ \/ __| __|
-  #   | |  __/\__ \ |
-  #   |_|\___||___/\__|
-  #
-  # for lib/facets/overload.rb
-  #
-  # Extracted Mon Sep 03 16:23:07 -0700 2007
-  # w/ Test Extraction Ratchet
-  #
-
- require 'facets/overload.rb'
-
-
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |
+#   |_|\___||___/\__|
+#
+
+require 'facets/overload.rb'
 
 require 'test/unit'
 

data/test/unit/test_paramix.rb

@@ -1,98 +1,92 @@
-  #  _____         _
-  # |_   _|__  ___| |_
-  #   | |/ _ \/ __| __|
-  #   | |  __/\__ \ |
-  #   |_|\___||___/\__|
-  #
-  # for lib/facets/paramix.rb
-  #
-  # Extracted Mon Sep 03 16:23:07 -0700 2007
-  # w/ Test Extraction Ratchet
-  #
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |
+#   |_|\___||___/\__|
+#
+# for facets/paramix.rb
 
- require 'facets/paramix.rb'
+require 'facets/paramix.rb'
 
+require 'test/unit'
 
+class TC_Paramix_01 < Test::Unit::TestCase
 
-  require 'test/unit'
-
-  class TC01 < Test::Unit::TestCase
-
-    module M
-      def f
-        M(:p)
-      end
-      def self.included_with_parameters( base, parms )
-        base.class_eval do
-          define_method :check do
-            parms
-          end
+  module M
+    def f
+      M(:p)
+    end
+    def self.included_with_parameters( base, parms )
+      base.class_eval do
+        define_method :check do
+          parms
         end
       end
     end
+  end
 
-    class C
-      include M, :p => "check"
-    end
-
-    class D
-      include M, :p => "steak"
-    end
+  class C
+    include M, :p => "check"
+  end
 
-    def test_01_001
-      c = C.new
-      assert_equal( "check", c.M(:p) )
-      assert_equal( "check", c.f )
-    end
+  class D
+    include M, :p => "steak"
+  end
 
-    def test_01_002
-      d = D.new
-      assert_equal( "steak", d.M(:p) )
-      assert_equal( "steak", d.f )
-    end
+  def test_01_001
+    c = C.new
+    assert_equal( "check", c.M(:p) )
+    assert_equal( "check", c.f )
+  end
 
-    def test_01_003
-      assert_equal( {M=>{:p => "check"}}, C.mixin_parameters )
-      assert_equal( {M=>{:p => "steak"}}, D.mixin_parameters )
-    end
+  def test_01_002
+    d = D.new
+    assert_equal( "steak", d.M(:p) )
+    assert_equal( "steak", d.f )
+  end
 
-    def test_01_004
-      c = C.new
-      assert_equal( {:p => "check"}, c.check )
-      d = D.new
-      assert_equal( {:p => "steak"}, d.check )
-    end
+  def test_01_003
+    assert_equal( {M=>{:p => "check"}}, C.mixin_parameters )
+    assert_equal( {M=>{:p => "steak"}}, D.mixin_parameters )
+  end
 
+  def test_01_004
+    c = C.new
+    assert_equal( {:p => "check"}, c.check )
+    d = D.new
+    assert_equal( {:p => "steak"}, d.check )
   end
 
+end
 
-  class TC02 < Test::Unit::TestCase
 
-    module M
-      def f
-        M(:p)
-      end
-    end
+class TC_Paramix_02 < Test::Unit::TestCase
 
-    class C
-      extend M, :p => "mosh"
+  module M
+    def f
+      M(:p)
     end
+  end
 
-    class D
-      extend M, :p => "many"
-    end
+  class C
+    extend M, :p => "mosh"
+  end
 
-    def test_02_001
-      assert_equal( "mosh", C.f )
-    end
+  class D
+    extend M, :p => "many"
+  end
 
-    def test_02_002
-      assert_equal( "many", D.f )
-    end
+  def test_02_001
+    assert_equal( "mosh", C.f )
+  end
 
-    def test_02_003
-      assert_equal( {M=>{:p => "mosh"}}, (class << C; self; end).mixin_parameters )
-      assert_equal( {M=>{:p => "many"}}, (class << D; self; end).mixin_parameters )
-    end
+  def test_02_002
+    assert_equal( "many", D.f )
+  end
 
+  def test_02_003
+    assert_equal( {M=>{:p => "mosh"}}, (class << C; self; end).mixin_parameters )
+    assert_equal( {M=>{:p => "many"}}, (class << D; self; end).mixin_parameters )
   end
+
+end