329 lines
6.6 KiB
Ruby
329 lines
6.6 KiB
Ruby
require 'helper'
|
|
|
|
testcase Dictionary do
|
|
include AE::Legacy::Assertions
|
|
|
|
class_method :[] do
|
|
test do
|
|
d = Dictionary['z', 1, 'a', 2, 'c', 3]
|
|
assert_equal( ['z','a','c'], d.keys )
|
|
end
|
|
end
|
|
|
|
class_method :new do
|
|
test "with default" do
|
|
d = Dictionary.new{ |hash,key| hash[key] = 0 }
|
|
d[:a] = 0
|
|
d[:b] += 1
|
|
assert_equal [0, 1], d.values
|
|
assert_equal [:a,:b], d.keys
|
|
end
|
|
end
|
|
|
|
method :[] do
|
|
test do
|
|
d = Dictionary['a', 1]
|
|
d['a'].assert == 1
|
|
end
|
|
end
|
|
|
|
method :[]= do
|
|
test do
|
|
d = Dictionary.new
|
|
d['z'] = 1
|
|
d['a'] = 2
|
|
d['c'] = 3
|
|
assert_equal( ['z','a','c'], d.keys )
|
|
end
|
|
end
|
|
|
|
method :[]= do
|
|
test do
|
|
d = Dictionary[]
|
|
d[:a] = 1
|
|
d[:c] = 3
|
|
assert_equal( [1,3], d.values )
|
|
d[:b,1] = 2
|
|
assert_equal( [1,2,3], d.values )
|
|
assert_equal( [:a,:b,:c], d.keys )
|
|
end
|
|
end
|
|
|
|
method :push do
|
|
test do
|
|
d = Dictionary['a', 1, 'c', 2, 'z', 3]
|
|
assert( d.push('end', 15) )
|
|
assert_equal( 15, d['end'] )
|
|
assert( ! d.push('end', 30) )
|
|
assert( d.unshift('begin', 50) )
|
|
assert_equal( 50, d['begin'] )
|
|
assert( ! d.unshift('begin', 60) )
|
|
assert_equal( ["begin", "a", "c", "z", "end"], d.keys )
|
|
assert_equal( ["end", 15], d.pop )
|
|
assert_equal( ["begin", "a", "c", "z"], d.keys )
|
|
assert_equal( ["begin", 50], d.shift )
|
|
end
|
|
end
|
|
|
|
method :insert do
|
|
test "front" do
|
|
d = Dictionary['a', 1, 'b', 2, 'c', 3]
|
|
r = Dictionary['d', 4, 'a', 1, 'b', 2, 'c', 3]
|
|
assert_equal( 4, d.insert(0,'d',4) )
|
|
assert_equal( r, d )
|
|
end
|
|
test "back" do
|
|
d = Dictionary['a', 1, 'b', 2, 'c', 3]
|
|
r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
|
|
assert_equal( 4, d.insert(-1,'d',4) )
|
|
assert_equal( r, d )
|
|
end
|
|
end
|
|
|
|
method :update do
|
|
test "with other orderred hash" do
|
|
d = Dictionary['a', 1, 'b', 2, 'c', 3]
|
|
c = Dictionary['d', 4]
|
|
r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
|
|
assert_equal( r, d.update(c) )
|
|
assert_equal( r, d )
|
|
end
|
|
test "with other hash" do
|
|
d = Dictionary['a', 1, 'b', 2, 'c', 3]
|
|
c = { 'd' => 4 }
|
|
r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
|
|
assert_equal( r, d.update(c) )
|
|
assert_equal( r, d )
|
|
end
|
|
end
|
|
|
|
method :merge do
|
|
test "with other orderred hash" do
|
|
d = Dictionary['a', 1, 'b', 2, 'c', 3]
|
|
c = Dictionary['d', 4]
|
|
r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
|
|
assert_equal( r, d.merge(c) )
|
|
end
|
|
test "with other hash" do
|
|
d = Dictionary['a', 1, 'b', 2, 'c', 3]
|
|
c = { 'd' => 4 }
|
|
r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
|
|
assert_equal( r, d.merge(c) )
|
|
end
|
|
end
|
|
|
|
method :order_by do
|
|
test do
|
|
d = Dictionary['a', 3, 'b', 2, 'c', 1]
|
|
d.order_by{ |k,v| v }
|
|
assert_equal( [1,2,3], d.values )
|
|
assert_equal( ['c','b','a'], d.keys )
|
|
end
|
|
end
|
|
|
|
method :reverse! do
|
|
test do
|
|
d = Dictionary['z', 1, 'a', 2, 'c', 3]
|
|
d.reverse!
|
|
assert_equal( ['c','a','z'], d.keys )
|
|
end
|
|
end
|
|
|
|
method :collect do
|
|
test "enumerable method" do
|
|
d = Dictionary[]
|
|
d[:a] = "a"
|
|
d[:c] = "b"
|
|
r = d.collect{|k,v| v.capitalize}
|
|
r.assert == ["A","B"]
|
|
end
|
|
end
|
|
|
|
method :dup do
|
|
test "with array values" do
|
|
d = Dictionary.new
|
|
d.dup
|
|
d[:a]=['t',5]
|
|
assert_equal(d, d.dup)
|
|
end
|
|
end
|
|
|
|
method :first do
|
|
test do
|
|
d = Dictionary[]
|
|
d[:a] = "a"
|
|
d[:b] = "b"
|
|
d[:c] = "c"
|
|
d.first.assert == "a"
|
|
d.first(0).assert == []
|
|
assert_equal ["a"] , d.first(1)
|
|
assert_equal ["a", "b"] , d.first(2)
|
|
end
|
|
end
|
|
|
|
method :last do
|
|
test do
|
|
d = Dictionary[]
|
|
d[:a] = "a"
|
|
d[:b] = "b"
|
|
d[:c] = "c"
|
|
d.last.assert == "c"
|
|
d.last(0).assert == []
|
|
d.last(1).assert == ["c"]
|
|
d.last(2).assert == ["b", "c"]
|
|
end
|
|
end
|
|
|
|
method :select do
|
|
test do
|
|
d = Dictionary[:a=>1, :b=>2, :c=>3]
|
|
r = d.select{ |k,v| v % 2 == 1 }
|
|
r.assert == [[:a, 1], [:c, 3]]
|
|
end
|
|
end
|
|
|
|
method :to_h do
|
|
test do
|
|
d = Dictionary[:a=>1, :b=>2]
|
|
h = d.to_h
|
|
h.assert == {:a=>1, :b=>2}
|
|
end
|
|
end
|
|
|
|
method :replace do
|
|
test do
|
|
d1 = Dictionary[:a=>1, :b=>2]
|
|
d2 = Dictionary[:c=>3, :d=>4]
|
|
d1.replace(d2)
|
|
d1.to_h.assert == {:c=>3, :d=>4}
|
|
end
|
|
end
|
|
|
|
method :reverse do
|
|
test do
|
|
d = Dictionary[:a=>1, :b=>2, :c=>3]
|
|
r = d.reverse
|
|
r.first.assert == 3
|
|
end
|
|
end
|
|
|
|
method :invert do
|
|
test do
|
|
d = Dictionary[:a=>1, :b=>2, :c=>3]
|
|
r = d.invert
|
|
Dictionary.assert === r
|
|
r.to_h.assert == {1=>:a, 2=>:b, 3=>:c}
|
|
end
|
|
end
|
|
|
|
method :each_key do
|
|
d = Dictionary[:a=>1, :b=>2, :c=>3]
|
|
d.order_by_key
|
|
a = []
|
|
d.each_key{ |k| a << k }
|
|
a.assert == [:a, :b, :c]
|
|
end
|
|
|
|
method :each_value do
|
|
d = Dictionary[:a=>1, :b=>2, :c=>3]
|
|
d.order_by_value
|
|
a = []
|
|
d.each_value{ |v| a << v }
|
|
a.assert == [1, 2, 3]
|
|
end
|
|
|
|
method :clear do
|
|
d = Dictionary[:a=>1, :b=>2, :c=>3]
|
|
d.clear
|
|
d.to_a.assert == []
|
|
end
|
|
|
|
method :fetch do
|
|
d = Dictionary[:a=>1, :b=>2, :c=>3]
|
|
d.fetch(:a).assert == 1
|
|
end
|
|
|
|
method :key? do
|
|
test do
|
|
d = Dictionary[:a=>1, :b=>2, :c=>3]
|
|
d.assert.key?(:a)
|
|
d.refute.key?(:d)
|
|
end
|
|
end
|
|
|
|
method :has_key? do
|
|
test do
|
|
d = Dictionary[:a=>1, :b=>2, :c=>3]
|
|
d.assert.has_key?(:a)
|
|
d.refute.has_key?(:d)
|
|
end
|
|
end
|
|
|
|
method :length do
|
|
test do
|
|
d = Dictionary[:a=>1, :b=>2, :c=>3]
|
|
d.length.assert == 3
|
|
end
|
|
end
|
|
|
|
method :to_a do
|
|
test do
|
|
d = Dictionary[:a=>1, :b=>2, :c=>3]
|
|
d.to_a.assert == [[:a,1], [:b,2], [:c,3]]
|
|
end
|
|
end
|
|
|
|
method :to_hash do
|
|
test do
|
|
d = Dictionary[:a=>1, :b=>2, :c=>3]
|
|
d.to_hash.assert == {:a=>1, :b=>2, :c=>3}
|
|
end
|
|
end
|
|
|
|
method :empty? do
|
|
test "is emtpy" do
|
|
d = Dictionary[]
|
|
d.assert.empty?
|
|
end
|
|
|
|
test 'is not emtpy' do
|
|
d = Dictionary[:a=>1, :b=>2, :c=>3]
|
|
d.refute.empty?
|
|
end
|
|
end
|
|
|
|
method :order_by_key do
|
|
test do
|
|
d = Dictionary[:b=>1, :c=>2, :a=>4]
|
|
d.order_by_key
|
|
d.order.assert == [:a, :b, :c]
|
|
end
|
|
end
|
|
|
|
method :order_by_value do
|
|
test do
|
|
d = Dictionary[:b=>1, :c=>2, :a=>4]
|
|
d.order_by_value
|
|
d.order.assert == [:b, :c, :a]
|
|
end
|
|
end
|
|
|
|
class_method :alpha do
|
|
test do
|
|
d = Dictionary.alpha
|
|
d.update(:b=>1, :c=>2, :a=>4)
|
|
d.order.assert == [:a, :b, :c]
|
|
end
|
|
end
|
|
|
|
class_method :auto do
|
|
test do
|
|
d = Dictionary.auto
|
|
s = d[:foo]
|
|
s.class.assert == Dictionary
|
|
end
|
|
end
|
|
|
|
end
|
|
|