JezK
Edit File: case_dictionary.rb
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