tb 0.1

data/sample/poi-xls2csv.sh

@@ -0,0 +1,39 @@
+#!/bin/sh
+
+# sample/poi-xls2csv.sh - script to run sample/poi-xls2csv.rb
+#
+# Copyright (C) 2011 Tanaka Akira  <akr@fsij.org>
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+#  1. Redistributions of source code must retain the above copyright notice, this
+#     list of conditions and the following disclaimer.
+#  2. Redistributions in binary form must reproduce the above copyright notice,
+#     this list of conditions and the following disclaimer in the documentation
+#     and/or other materials provided with the distribution.
+#  3. The name of the author may not be used to endorse or promote products
+#     derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+# WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+# EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+# OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+# IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+# OF SUCH DAMAGE.
+
+# Ubuntu libjakarta-poi-java package installs /usr/share/java/jakarta-poi.jar.
+
+d="`dirname $0`"
+d="`cd $d; pwd`"
+d="`dirname $d`"
+
+exec jruby -Ku \
+-I"$d/lib" \
+-I/usr/share/java \
+"$d/sample/poi-xls2csv.rb" \
+"$@"

data/test-all.rb

@@ -0,0 +1,7 @@
+$VERBOSE = true
+
+$:.unshift "lib"
+
+Dir.glob('test/test_*.rb') {|filename|
+  load filename
+}

data/test/test_basic.rb

@@ -0,0 +1,290 @@
+require 'tb'
+require 'test/unit'
+
+class TestTbBasic < Test::Unit::TestCase
+  def test_initialize
+    t = Tb.new
+    assert_equal([], t.list_fields)
+    t = Tb.new %w[fruit color],
+               %w[apple red],
+               %w[banana yellow],
+               %w[orange orange]
+    assert_equal(%w[fruit color].sort, t.list_fields.sort)
+    a = t.to_a.map {|r| r.to_h_with_reserved }
+    assert_operator(a, :include?, {"_recordid"=>0, "fruit"=>"apple", "color"=>"red"})
+    assert_operator(a, :include?, {"_recordid"=>1, "fruit"=>"banana", "color"=>"yellow"})
+    assert_operator(a, :include?, {"_recordid"=>2, "fruit"=>"orange", "color"=>"orange"})
+    assert_equal(3, a.length)
+  end
+
+  def test_replace
+    t1 = Tb.new %w[fruit color],
+                %w[apple red],
+                %w[banana yellow],
+                %w[orange orange]
+    t2 = Tb.new %w[grain color],
+                %w[rice white],
+                %w[wheat light-brown]
+    t1.replace t2
+    assert_equal([{"grain"=>"rice", "color"=>"white"},
+                  {"grain"=>"wheat", "color"=>"light-brown"}],
+                 t2.to_a.map {|rec| rec.to_h })
+  end
+
+  def test_enumerable
+    t = Tb.new
+    assert_kind_of(Enumerable, t)
+  end
+
+  def test_define_field
+    t = Tb.new %w[fruit color],
+               %w[apple red],
+               %w[banana yellow],
+               %w[orange orange]
+    t.define_field("namelen") {|record| record["fruit"].length }
+    t.each {|rec|
+      case rec['fruit']
+      when 'apple' then assert_equal(5, rec['namelen'])
+      when 'banana' then assert_equal(6, rec['namelen'])
+      when 'orange' then assert_equal(6, rec['namelen'])
+      else raise
+      end
+    }
+  end
+
+  def test_list_fields
+    t = Tb.new
+    assert_equal([], t.list_fields)
+    assert_equal([], t.list_fields)
+    assert_equal(["_recordid"], t.list_fields_all)
+    t = Tb.new %w[fruit color],
+               %w[apple red],
+               %w[banana yellow],
+               %w[orange orange]
+    assert_equal(%w[fruit color], t.list_fields)
+    assert_equal(%w[fruit color], t.list_fields)
+    assert_equal(%w[_recordid fruit color], t.list_fields_all)
+  end
+
+  def test_list_recordids
+    t = Tb.new
+    assert_equal([], t.list_recordids)
+    recordid1 = t.allocate_recordid
+    assert_equal([recordid1], t.list_recordids)
+    recordid2 = t.allocate_recordid
+    assert_equal([recordid1, recordid2], t.list_recordids)
+    assert_equal(nil, t.delete_recordid(recordid1))
+    assert_equal([recordid2], t.list_recordids)
+  end
+
+  def test_cell
+    t = Tb.new %w[f g]
+    recordid = t.allocate_recordid
+    assert_equal(nil, t.get_cell(recordid, :f))
+    t.set_cell(recordid, :f, 1)
+    assert_equal(1, t.get_cell(recordid, :f))
+    assert_equal(1, t.delete_cell(recordid, :f))
+    assert_equal(nil, t.get_cell(recordid, :f))
+    t.set_cell(recordid, :f, nil)
+    assert_equal(nil, t.get_cell(recordid, :f))
+    t.set_cell(recordid, :g, 2)
+    assert_equal(2, t.get_cell(recordid, :g))
+    t.set_cell(recordid, :g, nil)
+    assert_equal(nil, t.get_cell(recordid, :g))
+    t.delete_cell(recordid, :g)
+    assert_equal(nil, t.get_cell(recordid, :g))
+    t.delete_recordid(recordid)
+    assert_raise(IndexError) { t.get_cell(recordid, :g) }
+    assert_raise(IndexError) { t.get_cell(100, :g) }
+    assert_raise(IndexError) { t.get_cell(-1, :g) }
+    assert_raise(TypeError) { t.get_cell(:invalid_recordid, :g) }
+  end
+
+  def test_each_field
+    t = Tb.new %w[a b z]
+    a = []
+    t.each_field_with_reserved {|f| a << f }
+    assert_equal(%w[_recordid a b z], a)
+    a = []
+    t.each_field {|f| a << f }
+    assert_equal(%w[a b z], a)
+  end
+
+  def test_each_record
+    t = Tb.new %w[a], [1], [2]
+    records = []
+    t.each {|record| records << record.to_h_with_reserved }
+    assert_equal([{"_recordid"=>0, "a"=>1}, {"_recordid"=>1, "a"=>2}], records)
+  end
+
+  def test_categorize
+    t = Tb.new %w[a b c], [1,2,3], [2,4,3]
+    assert_raise(ArgumentError) { t.tb_categorize('a') }
+    assert_equal({1=>[2], 2=>[4]}, t.tb_categorize('a', 'b'))
+    assert_equal({1=>{2=>[3]}, 2=>{4=>[3]}}, t.tb_categorize('a', 'b', 'c'))
+    assert_equal({1=>[[2,3]], 2=>[[4,3]]}, t.tb_categorize('a', ['b', 'c']))
+    assert_equal({[1,2]=>[3], [2,4]=>[3]}, t.tb_categorize(['a', 'b'], 'c'))
+    assert_equal({3=>[2,4]}, t.tb_categorize('c', 'b'))
+    assert_equal({3=>[true,true]}, t.tb_categorize('c', lambda {|e| true }))
+    assert_equal({3=>2}, t.tb_categorize('c', 'b') {|ks, vs| vs.length } )
+    assert_equal({3=>2}, t.tb_categorize('c', 'b',
+                                      :seed=>0,
+                                      :update=> lambda {|ks, s, v| s + 1 }))
+    assert_equal({true => [1,2]}, t.tb_categorize(lambda {|e| true }, 'a'))
+    h = t.tb_categorize('a', lambda {|e| e })
+    assert_equal(2, h.size)
+    assert_equal([1, 2], h.keys.sort)
+    assert_instance_of(Array, h[1])
+    assert_instance_of(Array, h[2])
+    assert_equal(1, h[1].length)
+    assert_equal(1, h[2].length)
+    assert_instance_of(Tb::Record, h[1][0])
+    assert_instance_of(Tb::Record, h[2][0])
+    assert_same(t, h[1][0].table)
+    assert_same(t, h[2][0].table)
+    assert_equal(0, h[1][0].record_id)
+    assert_equal(1, h[2][0].record_id)
+    assert_same(t, h[2][0].table)
+
+    assert_raise(ArgumentError) { t.tb_categorize(:_foo, lambda {|e| true }) }
+    assert_equal({3=>[2], 6=>[4]}, t.tb_categorize(lambda {|rec| rec['a'] * 3 }, 'b'))
+    assert_equal({[1,2]=>[[2,3]], [2,4]=>[[4,3]]}, t.tb_categorize(['a', 'b'], ['b', 'c']))
+    assert_equal({1=>2, 2=>4}, t.tb_categorize('a', 'b', :seed=>0, :op=>:+))
+    assert_raise(ArgumentError) { t.tb_categorize('a', 'b', :op=>:+, :update=>lambda {|ks, s, v| v }) }
+    i = -1
+    assert_equal({3=>[0, 1]}, t.tb_categorize('c', lambda {|e| i += 1 }))
+  end
+
+  def test_unique_categorize
+    t = Tb.new %w[a b c], [1,2,3], [2,4,4]
+    assert_equal({1=>3, 2=>4}, t.tb_unique_categorize("a", "c"))
+    assert_equal({1=>[3], 2=>[4]}, t.tb_unique_categorize("a", "c", :seed=>nil) {|seed, v| !seed ? [v] : (seed << v) })
+    assert_equal({1=>1, 2=>1}, t.tb_unique_categorize("a", "c", :seed=>nil) {|seed, v| !seed ? 1 : seed + 1 })
+    assert_equal({1=>{2=>3}, 2=>{4=>4}}, t.tb_unique_categorize("a", "b", "c"))
+    t.insert({"a"=>2, "b"=>7, "c"=>8})
+    assert_equal({1=>{2=>3}, 2=>{4=>4, 7=>8}}, t.tb_unique_categorize("a", "b", "c"))
+  end
+
+  def test_unique_categorize_ambiguous
+    t = Tb.new %w[a b c], [1,2,3], [1,4,4]
+    assert_raise(ArgumentError) { t.tb_unique_categorize("a", "c") }
+    assert_equal({1=>[3,4]}, t.tb_unique_categorize("a", "c", :seed=>nil) {|seed, v| !seed ? [v] : (seed << v) })
+    assert_equal({1=>2}, t.tb_unique_categorize("a", "c", :seed=>nil) {|seed, v| !seed ? 1 : seed + 1 })
+  end
+
+  def test_category_count
+    t = Tb.new %w[a b c], [1,2,3], [2,4,3]
+    assert_equal({1=>1, 2=>1}, t.tb_category_count("a"))
+    assert_equal({2=>1, 4=>1}, t.tb_category_count("b"))
+    assert_equal({3=>2}, t.tb_category_count("c"))
+    assert_equal({3=>{1=>1, 2=>1}}, t.tb_category_count("c", "a"))
+  end
+
+  def test_natjoin2
+    t1 = Tb.new %w[a b], %w[1 2], %w[3 4], %w[0 4]
+    t2 = Tb.new %w[b c], %w[2 3], %w[4 5]
+    t3 = t1.natjoin2(t2)
+    assert_equal([{"_recordid"=>0, "a"=>"1", "b"=>"2", "c"=>"3"},
+                  {"_recordid"=>1, "a"=>"3", "b"=>"4", "c"=>"5"},
+                  {"_recordid"=>2, "a"=>"0", "b"=>"4", "c"=>"5"}], t3.to_a.map {|r| r.to_h_with_reserved })
+  end
+
+  def test_natjoin2_nocommon
+    t1 = Tb.new %w[a b], %w[1 2], %w[3 4]
+    t2 = Tb.new %w[c d], %w[5 6], %w[7 8]
+    t3 = t1.natjoin2(t2)
+    assert_equal([{"a"=>"1", "b"=>"2", "c"=>"5", "d"=>"6"},
+                  {"a"=>"1", "b"=>"2", "c"=>"7", "d"=>"8"},
+                  {"a"=>"3", "b"=>"4", "c"=>"5", "d"=>"6"},
+                  {"a"=>"3", "b"=>"4", "c"=>"7", "d"=>"8"}],
+                  t3.to_a.map {|r| r.to_h })
+  end
+
+  def test_fmap!
+    t = Tb.new %w[a b], %w[1 2], %w[3 4]
+    t.fmap!("a") {|record, v| "foo" + v }
+    assert_equal([{"_recordid"=>0, "a"=>"foo1", "b"=>"2"},
+                  {"_recordid"=>1, "a"=>"foo3", "b"=>"4"}], t.to_a.map {|r| r.to_h_with_reserved })
+  end
+
+  def test_delete_field
+    t = Tb.new(%w[a b], %w[1 2], %w[3 4])
+    t.delete_field("a")
+    assert_equal([{"_recordid"=>0, "b"=>"2"},
+                  {"_recordid"=>1, "b"=>"4"}], t.to_a.map {|r| r.to_h_with_reserved })
+  end
+
+  def test_delete_recordid
+    t = Tb.new %w[a]
+    recordid = t.insert({"a"=>"foo"})
+    t.insert({"a"=>"bar"})
+    t.delete_recordid(recordid)
+    t.insert({"a"=>"foo"})
+    records = []
+    t.each {|record|
+      record = record.to_h
+      record.delete('_recordid')
+      records << record
+    }
+    records = records.sort_by {|record| record['a'] }
+    assert_equal([{"a"=>"bar"}, {"a"=>"foo"}], records)
+  end
+
+  def test_rename_field
+    t1 = Tb.new %w[a b], [1, 2]
+    assert_equal([{"_recordid"=>0, "a"=>1, "b"=>2}], t1.to_a.map {|r| r.to_h_with_reserved })
+    t2 = t1.rename_field("a" => "c", "b" => "d")
+    assert_equal([{"_recordid"=>0, "a"=>1, "b"=>2}], t1.to_a.map {|r| r.to_h_with_reserved })
+    assert_equal([{"_recordid"=>0, "c"=>1, "d"=>2}], t2.to_a.map {|r| r.to_h_with_reserved })
+  end
+
+  def test_allocate_recordid
+    t = Tb.new
+    recordid1 = t.allocate_recordid(100)
+    assert_equal(100, recordid1)
+    recordid2 = t.allocate_recordid(200)
+    assert_equal(200, recordid2)
+    recordid3 = t.allocate_recordid
+    assert(recordid3 != recordid1)
+    assert(recordid3 != recordid2)
+  end
+
+  def test_reorder_fields!
+    t = Tb.new %w[fruit color],
+               %w[apple red],
+               %w[banana yellow],
+               %w[orange orange]
+    assert_equal(%w[fruit color], t.list_fields)
+    t.reorder_fields! %w[color fruit]
+    assert_equal(%w[_recordid color fruit], t.list_fields_all)
+    t.reorder_fields! %w[fruit _recordid color]
+    assert_equal(%w[fruit _recordid color], t.list_fields_all)
+  end
+
+  def test_has_field?
+    t = Tb.new %w[fruit color], 
+               %w[apple red], 
+               %w[banana yellow], 
+               %w[orange orange] 
+    assert_equal(true, t.has_field?("fruit"))
+    assert_equal(false, t.has_field?("foo"))
+  end
+
+  def test_filter
+    t = Tb.new %w[fruit color],
+               %w[apple red],
+               %w[banana yellow],
+               %w[orange orange]
+    t2 = t.filter {|rec| rec["fruit"] == "banana" }
+    assert_equal(1, t2.size)
+  end
+
+  def test_reorder_records_by
+    t = Tb.new %w[fruit color],
+               %w[apple red],
+               %w[banana yellow],
+               %w[orange orange]
+    t2 = t.reorder_records_by {|rec| rec["color"] }
+    assert_equal(t.map {|rec| rec["color"] }.sort, t2.map {|rec| rec["color"] })
+  end
+end

data/test/test_csv.rb

@@ -0,0 +1,78 @@
+require 'tb'
+require 'test/unit'
+
+class TestTbCSV < Test::Unit::TestCase
+  def test_parse
+    csv = <<-'End'.gsub(/^\s+/, '')
+    a,b
+    1,2
+    3,4
+    End
+    t = Tb.parse_csv(csv)
+    records = []
+    t.each_record {|record|
+      records << record.to_h_with_reserved
+    }
+    assert_equal(
+      [{"_recordid"=>0, "a"=>"1", "b"=>"2"},
+       {"_recordid"=>1, "a"=>"3", "b"=>"4"}],
+      records)
+  end
+
+  def test_parse_empty
+    csv = <<-'End'.gsub(/^\s+/, '')
+    a,b,c
+    1,,2
+    3,"",4
+    End
+    t = Tb.parse_csv(csv)
+    records = []
+    t.each_record {|record|
+      records << record.to_h_with_reserved
+    }
+    assert_equal(
+      [{"_recordid"=>0, "a"=>"1", "c"=>"2"},
+       {"_recordid"=>1, "a"=>"3", "b"=>"", "c"=>"4"}],
+      records)
+  end
+
+  def test_parse_conv
+    csv = "foo\na,b\n1,2\n"
+    t = Tb.parse_csv(csv) {|aa|
+      assert_equal([%w[foo],
+                   %w[a b],
+                   %w[1 2]],
+                   aa)
+      aa.shift
+      aa
+    }
+    records = []
+    t.each_record {|record|
+      records << record.to_h_with_reserved
+    }
+    assert_equal(
+      [{"_recordid"=>0, "a"=>"1", "b"=>"2"}],
+      records)
+  end
+
+  def test_generate
+    t = Tb.new %w[a b], [1, 2], [3, 4]
+    out = t.generate_csv('', ['a', 'b'])
+    assert_equal(<<-'End'.gsub(/^\s+/, ''), out)
+    a,b
+    1,2
+    3,4
+    End
+  end
+
+  def test_generate_empty
+    t = Tb.new %w[a b c], [1, nil, 2], [3, '', 4]
+    out = t.generate_csv('', ['a', 'b', 'c'])
+    assert_equal(<<-'End'.gsub(/^\s+/, ''), out)
+    a,b,c
+    1,,2
+    3,"",4
+    End
+  end
+
+end

data/test/test_enumerable.rb

@@ -0,0 +1,122 @@
+require 'tb/enumerable'
+require 'test/unit'
+
+class TestTbEnumerable < Test::Unit::TestCase
+  def test_categorize
+    a = [{:fruit => "banana", :color => "yellow", :taste => "sweet", :price => 100},
+         {:fruit => "melon", :color => "green", :taste => "sweet", :price => 300},
+         {:fruit => "grapefruit", :color => "yellow", :taste => "tart", :price => 200}]
+    assert_equal({"yellow"=>["banana", "grapefruit"], "green"=>["melon"]},
+                 a.tb_categorize(:color, :fruit))
+    assert_equal({"sweet"=>["banana", "melon"], "tart"=>["grapefruit"]},
+                 a.tb_categorize(:taste, :fruit))
+    assert_equal({"sweet"=>{"yellow"=>["banana"], "green"=>["melon"]}, "tart"=>{"yellow"=>["grapefruit"]}},
+                 a.tb_categorize(:taste, :color, :fruit))
+    assert_equal({"sweet"=>["yellow", "green"], "tart"=>["yellow"]},
+                 a.tb_categorize(:taste, :color))
+    assert_equal({?n=>["banana", "melon"], ?e=>["grapefruit"]},
+                 a.tb_categorize(lambda {|elt| elt[:fruit][4] }, :fruit))
+    
+    assert_equal({"yellow"=>[true, true], "green"=>[true]},
+                 a.tb_categorize(:color, lambda {|e| true }))
+    
+    i = -1
+    assert_equal({"yellow"=>[0, 2], "green"=>[1]},
+                 a.tb_categorize(:color, lambda {|e| i += 1 }))
+    
+    assert_equal({"yellow"=>[{:fruit=>"banana", :color=>"yellow", :taste=>"sweet", :price=>100},
+                             {:fruit=>"grapefruit", :color=>"yellow", :taste=>"tart", :price=>200}],
+                  "green"=>[{:fruit=>"melon", :color=>"green", :taste=>"sweet", :price=>300}]},
+                 a.tb_categorize(:color, lambda {|e| e }))
+    
+    assert_equal({"yellow"=>[{:fruit=>"banana", :color=>"yellow", :taste=>"sweet", :price=>100},
+                             {:fruit=>"grapefruit", :color=>"yellow", :taste=>"tart", :price=>200}],
+                  "green"=>[{:fruit=>"melon", :color=>"green", :taste=>"sweet", :price=>300}]},
+                 a.tb_categorize(:color, lambda {|e| e }))
+    
+    i = -1
+    assert_equal({"yellow"=>[["banana", "sweet", 0], ["grapefruit", "tart", 2]],
+                  "green"=>[["melon", "sweet", 1]]},
+                 a.tb_categorize(:color, [:fruit, :taste, lambda {|e| i += 1 }]))
+    
+    assert_equal({true=>["banana", "melon", "grapefruit"]},
+                 a.tb_categorize(lambda {|e| true }, :fruit))
+    
+    assert_equal({"yellow"=>2, "green"=>1},
+                 a.tb_categorize(:color, lambda {|e| true }, :seed=>0, :op=>lambda {|s, v| s+1 }))
+
+    assert_raise(ArgumentError) { a.tb_categorize(:color, lambda {|e| true }, :seed=>0,
+                                               :seed=>nil,
+                                               :op=>lambda {|s, v| s+1 },
+                                               :update=>lambda {|ks, s, v| s+1 }) }
+    
+    assert_equal({"yellow"=>"bananagrapefruit", "green"=>"melon"},
+                 a.tb_categorize(:color, :fruit, :seed=>"", :op=>:+))
+
+    assert_equal({"yellow"=>2, "green"=>1},
+                 a.tb_categorize(:color, lambda {|e| 1 }, :op=>:+))
+    
+    assert_equal({"yellow"=>"banana,grapefruit", "green"=>"melon"},
+                 a.tb_categorize(:color, :fruit) {|ks, vs| vs.join(",") } )
+    
+    assert_equal({"yellow"=>150.0, "green"=>300.0},
+                 a.tb_categorize(:color, :price) {|ks, vs| vs.inject(0.0, &:+) / vs.length })
+
+    assert_equal({"yellow"=>{"banana"=>100.0, "grapefruit"=>200.0}, "green"=>{"melon"=>300.0}},
+                 a.tb_categorize(:color, :fruit, :price) {|ks, vs| vs.inject(0.0, &:+) / vs.length })
+    
+    assert_raise(ArgumentError) { a.tb_categorize('a') }
+  end
+
+  def test_categorize_proc
+    c = Object.new
+    def c.call(v) 10 end
+    assert_equal({10=>[10]}, [[1]].tb_categorize(c, c))
+    assert_raise(NoMethodError) { [[1]].tb_categorize(0, 0, :seed=>nil, :update=>c) }
+    assert_raise(NoMethodError) { [[1]].tb_categorize(0, 0, :seed=>nil, :op=>c) }
+
+    t = Object.new
+    def t.to_proc() lambda {|*| 11 } end
+    assert_raise(TypeError) { [[1]].tb_categorize(t, t) }
+    assert_equal({1=>11}, [[1]].tb_categorize(0, 0, :seed=>nil, :update=>t))
+    assert_equal({1=>11}, [[1]].tb_categorize(0, 0, :seed=>nil, :op=>t))
+
+    ct = Object.new
+    def ct.call(v) 12 end
+    def ct.to_proc() lambda {|*| 13 } end
+    assert_equal({12=>[12]}, [[1]].tb_categorize(ct, ct))
+    assert_equal({1=>13}, [[1]].tb_categorize(0, 0, :seed=>nil, :update=>ct))
+    assert_equal({1=>13}, [[1]].tb_categorize(0, 0, :seed=>nil, :op=>ct))
+  end
+
+  def test_unique_categorize
+    a = [{:fruit => "banana", :color => "yellow", :taste => "sweet", :price => 100},
+         {:fruit => "melon", :color => "green", :taste => "sweet", :price => 300},
+         {:fruit => "grapefruit", :color => "yellow", :taste => "tart", :price => 200}]
+    assert_equal({"banana"=>100, "melon"=>300, "grapefruit"=>200},
+                 a.tb_unique_categorize(:fruit, :price))
+  
+    assert_raise(ArgumentError) { a.tb_unique_categorize(:color, :price) }
+  
+    assert_equal({"sweet"=>400, "tart"=>200},
+                 a.tb_unique_categorize(:taste, :price) {|s, v| !s ? v : s + v })
+  
+    assert_equal({"yellow"=>300, "green"=>300},
+                 a.tb_unique_categorize(:color, :price, :seed=>0) {|s, v| s + v })
+  end
+
+  def test_category_count
+    a = [{:fruit => "banana", :color => "yellow", :taste => "sweet", :price => 100},
+         {:fruit => "melon", :color => "green", :taste => "sweet", :price => 300},
+         {:fruit => "grapefruit", :color => "yellow", :taste => "tart", :price => 200}]
+  
+    assert_equal({"yellow"=>2, "green"=>1},
+                 a.tb_category_count(:color))
+  
+    assert_equal({"sweet"=>2, "tart"=>1},
+                 a.tb_category_count(:taste))
+  
+    assert_equal({"sweet"=>{"yellow"=>1, "green"=>1}, "tart"=>{"yellow"=>1}},
+                 a.tb_category_count(:taste, :color))
+  end
+end