facets 2.8.4 → 2.9.0.pre.1

data/test/core/file/test_ext.rb

@@ -1,30 +1,26 @@
-require 'facets/file/ext'
-require 'test/unit'
- 
-class Test_File_Ext < Test::Unit::TestCase
+covers 'facets/file/ext'
 
-  # Standard file names.  
-  def test_ext_standard
+tests File do
+
+  metaunit :ext => "typical filename" do
     s = 'file.txt'
-    assert_equal('txt', File.ext(s))
-    assert_equal('file.old', File.ext(s, 'old'))
-    assert_equal('file', File.ext(s, ''))
+    File.ext(s).assert == 'txt'
+    File.ext(s, 'old').assert == 'file.old'
+    File.ext(s, '').assert == 'file'
   end
 
-  # Initially no extension.
-  def test_ext_none
+  metaunit :ext => "no extension" do
     s = 'file'
-    assert_equal('', File.ext(s))
-    assert_equal('file.txt', File.ext(s, 'txt'))
-    assert_equal('file', File.ext(s, ''))
+    File.ext(s).assert == ''
+    File.ext(s, 'txt').assert == 'file.txt'
+    File.ext(s, '').assert == 'file'
   end 
 
-  # Some non-standard case.
-  def test_ext_non_standard
+  metaunit :ext => "non-standard extensions" do
     s = '.profile'
-    assert_equal('', File.ext(s))
-    assert_equal('.profile.new', File.ext(s, 'new'))
-    assert_equal('.profile', File.ext(s, ''))
+    File.ext(s).assert == ''
+    File.ext(s, 'new').assert == '.profile.new'
+    File.ext(s, '').assert == '.profile'
   end
 
 end

data/test/core/file/test_null.rb

@@ -1,11 +1,9 @@
-require 'test/unit'
-require 'facets/file/null'
+covers 'facets/file/null'
 
-class TC_File_Prime < Test::Unit::TestCase
+tests File do
 
-  # FIXME
-  def test_null
-    assert(File.null)
+  metaunit :null do
+    assert File.null
   end
 
 end

data/test/core/file/test_read_binary.rb

@@ -0,0 +1,15 @@
+covers 'facets/file/read_binary'
+
+tests File do
+
+  test_file = 'tmp/read_binary.txt'
+  test_data = "line 1\nline 2\nline 3"
+
+  # TODO: Is this even really testable?
+  metaunit :read_binary do
+    File.open(test_file, 'w'){ |f| f << test_data }
+    File.read_binary(test_file).assert == test_data
+  end
+
+end
+

data/test/core/file/test_read_list.rb

@@ -0,0 +1,12 @@
+covers 'facets/file/read_list'
+
+tests File do
+
+  test_file = 'tmp/read_list.txt'
+
+  metaunit :read_list do
+    File.open(test_file, 'w'){ |f| f << "line 1\nline 2\n#line 3" }
+    File.read_list(test_file).assert == ['line 1', 'line 2']
+  end
+
+end

data/test/core/file/test_rewrite.rb

@@ -1,32 +1,23 @@
-require 'facets/file/rewrite'
-require 'test/unit'
-#require 'tempfile'
+covers 'facets/file/rewrite'
 
-class Tets_File_Rewrite < Test::Unit::TestCase
+tests File do
 
-   class MockFile < ::File
-     def self.open( fname, mode, &blk )
-       blk.call(self)
-     end
-     def self.read( fname=nil )
-       @mock_content.clone
-     end
-     def self.write( str )
-       @mock_content = str
-     end
-     def self.<<( str )
-       (@mock_content ||="") << str
-     end
-   end
+  test_data = 'This is a test!'
 
-   def test_rewrite
-     f = "not-a-real-file.txt"
-     t = 'This is a test!'
-     MockFile.write( t )
-     MockFile.rewrite(f) { |s| s.reverse }
-     s = MockFile.read(f)
-     assert_equal( t.reverse, s )
-   end
+  context do
+    test_file = 'tmp/rewrite.txt'
+    File.open(test_file, 'w'){ |w| w << test_data }
+    test_file
+  end
 
-end
+  metaunit :rewrite do |test_file|
+    File.rewrite(test_file){ |s| s.reverse }
+    File.read(test_file).assert == test_data.reverse
+  end
+
+  metaunit :rewrite! do |test_file|
+    File.rewrite!(test_file){ |s| s.reverse! }
+    File.read(test_file).assert == test_data.reverse
+  end
 
+end

data/test/core/file/test_rootname.rb

@@ -0,0 +1,9 @@
+covers 'facets/file/rootname'
+
+tests File do
+
+  metaunit :rootname do
+    File.rootname('test/core/file').assert == 'test'
+  end
+
+end

data/test/core/file/test_sanitize.rb

@@ -0,0 +1,28 @@
+covers 'facets/file/sanitize'
+
+tests File do
+
+  # TODO: Write file identity tests.
+  metaunit :sanitize => "spaces become underscores" do
+    File.sanitize('This is a test').assert == "This_is_a_test"
+  end
+
+  metaunit :sanitize => "Windows-style path dividers" do
+    File.sanitize('This\is\test').assert == "test"
+  end
+
+  metaunit :sanitize => "Unix-style path dividers" do
+    File.sanitize('This/is/test').assert == "test"
+  end
+
+  metaunit :sanitize => "non-word characters" do
+    File.sanitize('This/te#$#@!st').assert == "te_____st"
+  end
+
+  metaunit :sanitize => "initial dot" do
+    File.sanitize('.').assert == "_."
+    File.sanitize('....').assert == "_...."
+  end
+
+end
+

data/test/core/file/test_split_all.rb

@@ -1,32 +1,10 @@
-# Test for facets/file/topath.rb
+covers 'facets/file/split_all'
 
-require 'facets/file/split_all.rb'
+tests File do
 
-require 'test/unit'
-
-
-class TC_File_Split_All < Test::Unit::TestCase
-
-  # mock file
-
-  class MockFile < File
-    def self.open( fname, mode, &blk )
-      blk.call(self)
-    end
-    def self.read( fname=nil )
-      @mock_content.clone
-    end
-    def self.write( str )
-      @mock_content = str
-    end
-    def self.<<( str )
-      (@mock_content ||="") << str
-    end
-  end
-
-  def test_split_all
-    fp = "this/is/test"
-    assert_equal( ['this', 'is', 'test'], MockFile.split_all(fp) )
+  metaunit :split_all do
+    fp = "test/core/file"
+    File.split_all(fp).assert == ['test', 'core', 'file']
   end
 
 end

data/test/core/file/test_write.rb

@@ -1,30 +1,17 @@
-require 'facets/file/write'
-require 'test/unit'
-require 'tempfile'
+covers 'facets/file/write'
 
-class TC_File_Write < Test::Unit::TestCase
+tests File do
 
-  def setup
-    tmp_dir = Dir::tmpdir # ENV["TMP"] || ENV["TEMP"] || "/tmp"
-    raise "Can't find temporary directory" unless File.directory?(tmp_dir)
-    @path = File.join(tmp_dir, "ruby_io_test")
-  end
+  test_file = 'tmp/write.txt'
 
-  # Test File.write
-  def test_file_write
-    data_in = "Test data\n"
-    nbytes = File.write(@path, data_in)
-    data_out = File.read(@path)          # This is standard class method.
-    assert_equal(data_in, data_out)
-    assert_equal(data_out.size, nbytes)
-  end
+  metaunit :write do
+    data = "Test data\n"
+
+    nbytes = File.write(test_file, data)
 
-  # Test File.writelines
-  def test_file_writelines
-    data_in = %w[one two three four five]
-    File.writelines(@path, data_in)
-    data_out = File.readlines(@path)     # This is standard class method.
-    assert_equal(data_in, data_out.map { |l| l.chomp })
+    out = File.read(test_file)
+    out.assert == data
+    out.size.assert == nbytes
   end
 
 end

data/test/core/file/test_writelines.rb

@@ -1,21 +1,16 @@
-require 'facets/file/write'
-require 'test/unit'
-require 'tempfile'
+covers 'facets/file/writelines'
 
-class TC_File_Writelines < Test::Unit::TestCase
+#require File.dirname(__FILE__) + '/helpers/mockfile'
+tests File do
 
-  def setup
-    tmp_dir = Dir::tmpdir # ENV["TMP"] || ENV["TEMP"] || "/tmp"
-    raise "Can't find temporary directory" unless File.directory?(tmp_dir)
-    @path = File.join(tmp_dir, "ruby_io_test")
-  end
+  test_file = 'tmp/writelines.txt'
+  test_data = %w[one two three four five]
+
+  metaunit :writelines do
+    File.writelines(test_file, test_data)
 
-  # Test File.writelines
-  def test_file_writelines
-    data_in = %w[one two three four five]
-    File.writelines(@path, data_in)
-    data_out = File.readlines(@path)     # This is standard class method.
-    assert_equal(data_in, data_out.map { |l| l.chomp })
+    out = File.readlines(test_file)
+    out.map{ |l| l.chomp }.assert == test_data
   end
 
 end

data/test/core/filetest/test_root.rb

@@ -0,0 +1,10 @@
+covers 'facets/filetest/root'
+
+testcase FileTest do
+
+  metaunit :root? do
+    assert FileTest.root?('/')
+  end
+
+end
+

data/test/core/functor_tc.rb

@@ -0,0 +1,29 @@
+covers 'facets/functor'
+
+tests Functor do
+
+  metaunit :new do
+    fc = Functor.new do |op, *a, &b|
+      [op, a, b]
+    end
+    (fc + 1).assert == [:+, [1], nil]
+  end
+
+  unit :__class__ do
+    fc = Functor.new do |op, *a, &b|
+      [op, a, b]
+    end
+    fc.__class__.assert == Functor
+  end
+
+  unit :to_proc do
+    f = Functor.new do |op, *a|
+      [op, *a]
+    end
+    p = f.to_proc
+    p.assert.is_a? Proc
+    p.call(:+,1,2,3).assert == [:+,1,2,3]
+  end
+
+end
+

data/test/core/hash/test_alias.rb

@@ -1,15 +1,16 @@
-require 'facets/hash/alias.rb'
-require 'test/unit'
+covers 'facets/hash/alias'
 
-class TestHashRekey < Test::Unit::TestCase
+testcase Hash do
 
-  def test_alias!
+  unit :alias! do
     foo = { 'a'=>1, 'b'=>2 }
-    assert_equal( { 'a'=>1, 'b'=>2, 'c'=>2 }, foo.alias!('c','b') )
+    foo.alias!('c','b').assert == { 'a'=>1, 'b'=>2, 'c'=>2 }
+
     foo = { 'a'=>1, 'b'=>2 }
-    assert_equal( { :a=>1, 'a'=>1, 'b'=>2 }, foo.alias!(:a,'a') )
+    foo.alias!(:a,'a').assert == { :a=>1, 'a'=>1, 'b'=>2 }
+
     foo = { :a=>1, :b=>2 }
-    assert_equal( { :a=>1, :b=>2 }, foo.alias!('bar','foo') )
+    foo.alias!('bar','foo').assert == { :a=>1, :b=>2 }
   end
 
 end

data/test/core/hash/test_argumentize.rb

@@ -0,0 +1,19 @@
+covers 'facets/hash/argumentize'
+
+testcase Hash do
+
+  instance do
+    { :list => [1,2], :base => "HI" }
+  end
+
+  unit :argumentize => "without an argument field" do |h|
+    h.argumentize.assert == [ { :list => [1,2], :base => "HI" } ]
+  end
+
+  unit :argumentize => "with an argument field" do |h|
+    h.argumentize(:list).assert == [ 1, 2, { :base => "HI" } ]
+    h.argumentize(:base).assert == [ "HI", { :list => [1,2] } ]
+  end
+
+end
+

data/test/core/hash/test_at.rb

@@ -1,12 +1,11 @@
-require 'facets/hash/at'
-require 'test/unit'
+covers 'facets/hash/at'
 
-class TC_Hash_At < Test::Unit::TestCase
+testcase Hash do
 
-  def test_at
+  unit :at do
     h = { :a=>1, :b=>2 }
-    assert_equal( 1, h.at(:a) )
-    assert_equal( 2, h.at(:b) )
+    h.at(:a).assert == 1
+    h.at(:b).assert == 2
   end
 
 end

data/test/core/hash/test_autonew.rb

@@ -1,10 +1,17 @@
-require 'facets/hash/autonew'
-require 'test/unit'
+covers 'facets/hash/autonew'
 
-class TC_Hash_AutoNew < Test::Unit::TestCase
+testcase Hash do
 
-  def test_autonew
-    # TODO
+  metaunit :autonew do
+    h = Hash.autonew
+    h['s1']['p1'] = 4
+    h['s1']['p2'] = 5
+    h['s1']['p3'] = 2
+    h['s1']['p4'] = 3
+  
+    h.assert == {"s1"=>{"p1"=>4, "p4"=>3, "p3"=>2, "p2"=>5}}
+  
+    h['s1'].keys.sort.assert == ["p1", "p2", "p3", "p4"]
   end
 
 end

data/test/core/hash/test_collate.rb

@@ -1,32 +1,50 @@
-require 'facets/hash/collate'
-require 'test/unit'
+covers 'facets/hash/collate'
 
-class TC_Hash_Collation < Test::Unit::TestCase
+tests Hash do
 
-  def setup
-    @a = { :a=>1, :b=>2, :z=>26, :all=>%w|a b z|, :stuff1=>%w|foo bar|, :whee=>%w|a b| }
-    @b = { :a=>1, :b=>4, :c=>9,  :all=>%w|a b c|, :stuff2=>%w|jim jam|, :whee=>%w|a b| }
-    @c = { :a=>1, :b=>8, :c=>27 }
+  a = { :a=>1, :b=>2, :z=>26, :all=>%w|a b z|, :stuff1=>%w|foo bar|, :whee=>%w|a b| }
+  b = { :a=>1, :b=>4, :c=>9,  :all=>%w|a b c|, :stuff2=>%w|jim jam|, :whee=>%w|a b| }
+  c = { :a=>1, :b=>8, :c=>27 }
+
+  unit :collate do
+    collated = a.collate(b)
+
+    collated.keys.length.assert == 8
+
+    collated[:a].assert == [1,1]
+    collated[:b].assert == [2,4]
+    collated[:c].assert == [9]
+    collated[:z].assert == [26]
+
+    collated[:all].assert == %w|a b z a b c|
+    collated[:stuff1].assert == %w|foo bar|
+    collated[:stuff2].assert == %w|jim jam|
+    collated[:whee].assert == %w|a b a b|
   end
 
-  def test_defaults
-    collated = @a.collate(@b)
-    assert_equal( 8, collated.keys.length, "There are 7 unique keys" )
-    assert_equal( [1,1], collated[ :a ] )
-    assert_equal( [2,4], collated[ :b ] )
-    assert_equal( [9],   collated[ :c ] )
-    assert_equal( [26],  collated[ :z ] )
-    assert_equal( %w|a b z a b c|,  collated[ :all ], "Arrays are merged by default." )
-    assert_equal( %w|foo bar|,  collated[ :stuff1 ] )
-    assert_equal( %w|jim jam|,  collated[ :stuff2 ] )
-    assert_equal( %w|a b a b|,  collated[ :whee ] )
+  unit :collate => "multiple times" do
+    collated = a.collate(b).collate(c)
+
+    collated[:a].assert == [1,1,1]
+    collated[:b].assert == [2,4,8]
+    collated[:c].assert == [9,27]
   end
 
-  def test_multi_collate
-    collated = @a.collate(@b).collate(@c)
-    assert_equal( [1,1,1], collated[ :a ] )
-    assert_equal( [2,4,8], collated[ :b ] )
-    assert_equal( [9,27],  collated[ :c ] )
+  unit :collate! => "in place variant of #collate" do
+    collated = a.dup
+    collated.collate!(b)
+
+    collated.keys.length.assert == 8
+
+    collated[:a].assert == [1,1]
+    collated[:b].assert == [2,4]
+    collated[:c].assert == [9]
+    collated[:z].assert == [26]
+
+    collated[:all].assert == %w|a b z a b c|
+    collated[:stuff1].assert == %w|foo bar|
+    collated[:stuff2].assert == %w|jim jam|
+    collated[:whee].assert == %w|a b a b|
   end
 
 end