diakonos 0.8.3

data/test/clipboard-test.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'diakonos/clipboard'
+
+class TC_Clipboard < Test::Unit::TestCase
+    def test_01_addClip
+        c = Diakonos::Clipboard.new( 3 )
+        assert_equal false, c.addClip( nil )
+        assert_equal true, c.addClip( [ 'foo' ] )
+        assert_equal true, c.addClip( [ 'bar' ] )
+        assert_equal true, c.addClip( [ 'baz' ] )
+        assert_equal [ 'foo' ], c[ 2 ]
+        assert_nil c[ 3 ]
+        assert_equal true, c.addClip( [ 'fiz' ] )
+        assert_equal [ 'bar' ], c[ 2 ]
+        assert_nil c[ 3 ]
+    end
+    
+    def test_02_brackets
+        c = Diakonos::Clipboard.new( 3 )
+        assert_nil c[ -1 ]
+        assert_nil c[ 0 ]
+        assert_nil c[ 1 ]
+        assert_equal false, c.addClip( nil )
+        x = [ 'foo' ]
+        assert_equal true, c.addClip( x )
+        assert_equal x, c[ -1 ]
+        assert_equal x, c[ 0 ]
+        assert_nil c[ 1 ]
+    end
+    
+    def test_03_each
+        c = Diakonos::Clipboard.new( 10 )
+        9.downto( 0 ) do |i|
+            c.addClip( [ i.to_s ] )
+        end
+        i = 0
+        c.each do |clip|
+            assert_equal( [ i.to_s ], clip )
+            i += 1
+        end
+    end
+    
+    def test_04_appendToClip
+        c = Diakonos::Clipboard.new( 10 )
+        assert_equal false, c.appendToClip( nil )
+        x = [ 'foo' ]
+        assert_equal true, c.appendToClip( x )
+        assert_equal(
+            [ 'foo' ],
+            c.clip
+        )
+        
+        assert_equal true, c.appendToClip( [ 'bar', 'baz' ] )
+        assert_equal(
+            [ 'foo', 'bar', 'baz' ],
+            c.clip
+        )
+        
+        y = [ 'line with newline', '' ]
+        assert_equal true, c.addClip( y )
+        assert_equal y, c.clip
+        assert_equal true, c.appendToClip( [ 'another line' ] )
+        assert_equal(
+            [ 'line with newline', 'another line' ],
+            c.clip
+        )
+    end
+end

data/test/diakonos-test.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'diakonos'
+
+class TC_Diakonos < Test::Unit::TestCase
+    def setup
+        $diakonos = Diakonos::Diakonos.new
+    end
+    
+    def test_true
+        assert true
+    end
+end

data/test/hash-test.rb

@@ -0,0 +1,404 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'diakonos'
+
+class TC_Hash < Test::Unit::TestCase
+    def test_deleteKeyPath
+        g = {}
+        h = g.deep_clone
+        assert_equal(
+            {},
+            h.deleteKeyPath( [] )
+        )
+        h = g.deep_clone
+        assert_equal(
+            {},
+            h.deleteKeyPath( [ 'test' ] )
+        )
+        h = g.deep_clone
+        assert_equal(
+            {},
+            h.deleteKeyPath( [ 'test', 'test2' ] )
+        )
+        
+        g = { 'a' => 'x' }
+        h = g.deep_clone
+        assert_equal(
+            { 'a' => 'x' },
+            h.deleteKeyPath( [] )
+        )
+        h = g.deep_clone
+        assert_equal(
+            { 'a' => 'x' },
+            h.deleteKeyPath( [ 'test' ] )
+        )
+        h = g.deep_clone
+        assert_equal(
+            { 'a' => 'x' },
+            h.deleteKeyPath( [ 'test', 'test2' ] )
+        )
+        h = g.deep_clone
+        assert_equal(
+            {},
+            h.deleteKeyPath( [ 'a' ] )
+        )
+        h = g.deep_clone
+        assert_equal(
+            { 'a' => 'x' },
+            h.deleteKeyPath( [ 'a', 'b' ] )
+        )
+        
+        g = {
+            'a' => {
+                'b' => 'x'
+            }
+        }
+        h = g.deep_clone
+        assert_equal(
+            { 'a' => { 'b' => 'x' } },
+            h.deleteKeyPath( [] )
+        )
+        h = g.deep_clone
+        assert_equal(
+            { 'a' => { 'b' => 'x' } },
+            h.deleteKeyPath( [ 'z' ] )
+        )
+        h = g.deep_clone
+        assert_equal(
+            { 'a' => { 'b' => 'x' } },
+            h.deleteKeyPath( [ 'z', 'zz' ] )
+        )
+        h = g.deep_clone
+        assert_equal(
+            { 'a' => { 'b' => 'x' } },
+            h.deleteKeyPath( [ 'a', 'b', 'c' ] )
+        )
+        h = g.deep_clone
+        assert_equal(
+            {},
+            h.deleteKeyPath( [ 'a' ] )
+        )
+        h = g.deep_clone
+        assert_equal(
+            {},
+            h.deleteKeyPath( [ 'a', 'b' ] )
+        )
+        
+        g = {
+            'a' => {
+                'b' => 'x',
+                'c' => 'y'
+            }
+        }
+        h = g.deep_clone
+        assert_equal(
+            { 'a' => { 'b' => 'x', 'c' => 'y' } },
+            h.deleteKeyPath( [] )
+        )
+        h = g.deep_clone
+        assert_equal(
+            { 'a' => { 'b' => 'x', 'c' => 'y' } },
+            h.deleteKeyPath( [ 'z' ] )
+        )
+        h = g.deep_clone
+        assert_equal(
+            { 'a' => { 'b' => 'x', 'c' => 'y' } },
+            h.deleteKeyPath( [ 'z', 'zz' ] )
+        )
+        h = g.deep_clone
+        assert_equal(
+            { 'a' => { 'b' => 'x', 'c' => 'y' } },
+            h.deleteKeyPath( [ 'a', 'b', 'c' ] )
+        )
+        h = g.deep_clone
+        assert_equal(
+            {},
+            h.deleteKeyPath( [ 'a' ] )
+        )
+        h = g.deep_clone
+        assert_equal(
+            { 'a' => { 'c' => 'y' } },
+            h.deleteKeyPath( [ 'a', 'b' ] )
+        )
+        h = g.deep_clone
+        assert_equal(
+            { 'a' => { 'b' => 'x' } },
+            h.deleteKeyPath( [ 'a', 'c' ] )
+        )
+        
+        g = {
+            'a' => {
+                'b' => 'x'
+            },
+            'c' => {
+                'd' => 'y'
+            }
+        }
+        h = g.deep_clone
+        assert_equal(
+            { 'a' => { 'b' => 'x' }, 'c' => { 'd' => 'y' } },
+            h.deleteKeyPath( [] )
+        )
+        h = g.deep_clone
+        assert_equal(
+            { 'a' => { 'b' => 'x' }, 'c' => { 'd' => 'y' } },
+            h.deleteKeyPath( [ 'z' ] )
+        )
+        h = g.deep_clone
+        assert_equal(
+            { 'a' => { 'b' => 'x' }, 'c' => { 'd' => 'y' } },
+            h.deleteKeyPath( [ 'z', 'zz' ] )
+        )
+        h = g.deep_clone
+        assert_equal(
+            { 'a' => { 'b' => 'x' }, 'c' => { 'd' => 'y' } },
+            h.deleteKeyPath( [ 'a', 'b', 'c' ] )
+        )
+        h = g.deep_clone
+        assert_equal(
+            { 'c' => { 'd' => 'y' } },
+            h.deleteKeyPath( [ 'a' ] )
+        )
+        h = g.deep_clone
+        assert_equal(
+            { 'a' => { 'b' => 'x' } },
+            h.deleteKeyPath( [ 'c' ] )
+        )
+        h = g.deep_clone
+        assert_equal(
+            { 'c' => { 'd' => 'y' } },
+            h.deleteKeyPath( [ 'a', 'b' ] )
+        )
+        h = g.deep_clone
+        assert_equal(
+            { 'a' => { 'b' => 'x' } },
+            h.deleteKeyPath( [ 'c', 'd' ] )
+        )
+    end
+    
+    def test_setKeyPath
+        g = {}
+        h = g.deep_clone
+        assert_equal(
+            {},
+            h.setKeyPath( [], 'x' )
+        )
+        h = g.deep_clone
+        assert_equal(
+            { 'a' => 'x' },
+            h.setKeyPath( [ 'a' ], 'x' )
+        )
+        h = g.deep_clone
+        assert_equal(
+            { 'a' => { 'b' => 'x' } },
+            h.setKeyPath( [ 'a', 'b' ], 'x' )
+        )
+        
+        g = { 'a' => 'x' }
+        h = g.deep_clone
+        assert_equal(
+            { 'a' => 'x' },
+            h.setKeyPath( [], 'x' )
+        )
+        h = g.deep_clone
+        assert_equal(
+            { 'a' => 'x' },
+            h.setKeyPath( [ 'a' ], 'x' )
+        )
+        h = g.deep_clone
+        assert_equal(
+            { 'a' => { 'b' => 'x' } },
+            h.setKeyPath( [ 'a', 'b' ], 'x' )
+        )
+        
+        g = { 'c' => 'y' }
+        h = g.deep_clone
+        assert_equal(
+            { 'c' => 'y' },
+            h.setKeyPath( [], 'x' )
+        )
+        h = g.deep_clone
+        assert_equal(
+            { 'c' => 'y', 'a' => 'x' },
+            h.setKeyPath( [ 'a' ], 'x' )
+        )
+        h = g.deep_clone
+        assert_equal(
+            { 'c' => 'y', 'a' => { 'b' => 'x' } },
+            h.setKeyPath( [ 'a', 'b' ], 'x' )
+        )
+        
+        g = { 'a' => { 'b' => 'x' } }
+        h = g.deep_clone
+        assert_equal(
+            { 'a' => { 'b' => 'x' } },
+            h.setKeyPath( [], 'x' )
+        )
+        h = g.deep_clone
+        assert_equal(
+            { 'a' => 'x' },
+            h.setKeyPath( [ 'a' ], 'x' )
+        )
+        h = g.deep_clone
+        assert_equal(
+            { 'a' => { 'b' => 'x' }, 'c' => 'y' },
+            h.setKeyPath( [ 'c' ], 'y' )
+        )
+        h = g.deep_clone
+        assert_equal(
+            { 'a' => { 'b' => 'x' }, 'c' => { 'd' => 'y' } },
+            h.setKeyPath( [ 'c', 'd' ], 'y' )
+        )
+    end
+    
+    def test_getNode
+        h = {}
+        assert_equal(
+            nil,
+            h.getNode( [] )
+        )
+        assert_equal(
+            nil,
+            h.getNode( [ 'a' ] )
+        )
+        assert_equal(
+            nil,
+            h.getNode( [ 'a', 'b' ] )
+        )
+        
+        h = { 'a' => 'x' }
+        assert_equal(
+            nil,
+            h.getNode( [] )
+        )
+        assert_equal(
+            nil,
+            h.getNode( [ 'b' ] )
+        )
+        assert_equal(
+            'x',
+            h.getNode( [ 'a' ] )
+        )
+        
+        h = { 'a' => { 'b' => 'x' } }
+        assert_equal(
+            nil,
+            h.getNode( [] )
+        )
+        assert_equal(
+            nil,
+            h.getNode( [ 'b' ] )
+        )
+        assert_equal(
+            { 'b' => 'x' },
+            h.getNode( [ 'a' ] )
+        )
+        assert_equal(
+            nil,
+            h.getNode( [ 'a', 'b', 'c' ] )
+        )
+        assert_equal(
+            nil,
+            h.getNode( [ 'a', 'c' ] )
+        )
+        assert_equal(
+            'x',
+            h.getNode( [ 'a', 'b' ] )
+        )
+    end
+    
+    def test_getLeaf
+        h = {}
+        assert_equal(
+            nil,
+            h.getLeaf( [] )
+        )
+        assert_equal(
+            nil,
+            h.getLeaf( [ 'a' ] )
+        )
+        assert_equal(
+            nil,
+            h.getLeaf( [ 'a', 'b' ] )
+        )
+        
+        h = { 'a' => 'x' }
+        assert_equal(
+            nil,
+            h.getLeaf( [] )
+        )
+        assert_equal(
+            nil,
+            h.getLeaf( [ 'b' ] )
+        )
+        assert_equal(
+            'x',
+            h.getLeaf( [ 'a' ] )
+        )
+        
+        h = { 'a' => { 'b' => 'x' } }
+        assert_equal(
+            nil,
+            h.getLeaf( [] )
+        )
+        assert_equal(
+            nil,
+            h.getLeaf( [ 'b' ] )
+        )
+        assert_equal(
+            nil,
+            h.getLeaf( [ 'a' ] )
+        )
+        assert_equal(
+            nil,
+            h.getLeaf( [ 'a', 'b', 'c' ] )
+        )
+        assert_equal(
+            nil,
+            h.getLeaf( [ 'a', 'c' ] )
+        )
+        assert_equal(
+            'x',
+            h.getLeaf( [ 'a', 'b' ] )
+        )
+    end
+    
+    def test_leaves
+        h = {}
+        assert_equal(
+            Set.new( [] ),
+            h.leaves
+        )
+        
+        h = { 'a' => 'x' }
+        assert_equal(
+            Set.new( [ 'x' ] ),
+            h.leaves
+        )
+        
+        h = { 'a' => 'x', 'b' => 'y' }
+        assert_equal(
+            Set.new( [ 'x', 'y' ] ),
+            h.leaves
+        )
+        
+        h = { 'a' => { 'b' => 'x' }, 'c' => 'y' }
+        assert_equal(
+            Set.new( [ 'x', 'y' ] ),
+            h.leaves
+        )
+        
+        h = { 'a' => { 'b' => 'x' }, 'c' => { 'd' => 'y' } }
+        assert_equal(
+            Set.new( [ 'x', 'y' ] ),
+            h.leaves
+        )
+        
+        h = { 'a' => { 'b' => 'x' }, 'c' => { 'd' => 'y', 'e' => 'z' }, 'f' => 'w' }
+        assert_equal(
+            Set.new( [ 'x', 'y', 'z', 'w' ] ),
+            h.leaves
+        )
+    end
+end