kyanite 0.3.1

data/test/string/test_split.rb

@@ -0,0 +1,187 @@
+
+require 'kyanite/unit_test'
+require 'kyanite/smart_load_path'; smart_load_path
+require 'perception'                                if $0 == __FILE__    
+
+require 'kyanite/string/split'
+
+
+class TestKyaniteStringSplit < UnitTest
+    
+  def test_nchar
+     assert_equal 'a',      'abcde'.nchar(1)    
+     assert_equal 'ab',     'abcde'.nchar(2) 
+     assert_equal 'abc',    'abcde'.nchar(3) 
+     assert_equal 'abcd',   'abcde'.nchar(4) 
+     assert_equal 'abcde',  'abcde'.nchar(5) 
+     assert_equal 'abcde',  'abcde'.nchar(6) 
+     
+     assert_equal '',       'abcde'.nchar(0)    
+     assert_equal 'e',      'abcde'.nchar(-1)      
+     assert_equal 'de',     'abcde'.nchar(-2)      
+     assert_equal 'cde',    'abcde'.nchar(-3)      
+     assert_equal 'bcde',   'abcde'.nchar(-4)      
+     assert_equal 'abcde',  'abcde'.nchar(-5)      
+     assert_equal 'abcde',  'abcde'.nchar(-6)     
+
+     assert_equal 'abcde',  'abcde'.nchar(0,'')    
+     assert_equal 'bcde',   'abcde'.nchar(1,'')    
+     assert_equal 'cde',    'abcde'.nchar(2,'') 
+     assert_equal 'de',     'abcde'.nchar(3,'') 
+     assert_equal 'e',      'abcde'.nchar(4,'') 
+     assert_equal '',       'abcde'.nchar(5,'') 
+     assert_equal '',       'abcde'.nchar(6,'')   
+
+     assert_equal 'abcde',  'abcde'.nchar(0,'')    
+     assert_equal 'abcd',   'abcde'.nchar(-1,'')    
+     assert_equal 'abc',    'abcde'.nchar(-2,'') 
+     assert_equal 'ab',     'abcde'.nchar(-3,'') 
+     assert_equal 'a',      'abcde'.nchar(-4,'') 
+     assert_equal '',       'abcde'.nchar(-5,'') 
+     assert_equal '',       'abcde'.nchar(-6,'')         
+  end
+  
+    
+  
+  def test_split_by_index
+     assert_equal ['', 'abcde'],     'abcde'.split_by_index(0)   
+     assert_equal ['a', 'bcde'],     'abcde'.split_by_index(1)    
+     assert_equal ['ab', 'cde'],     'abcde'.split_by_index(2)    
+     assert_equal ['abc', 'de'],     'abcde'.split_by_index(3)    
+     assert_equal ['abcd', 'e'],     'abcde'.split_by_index(4)    
+     assert_equal ['abcde', ''],     'abcde'.split_by_index(5)    
+     assert_equal ['abcde', ''],     'abcde'.split_by_index(6)    
+     assert_equal ['abcde', ''],     'abcde'.split_by_index(1000)    
+      
+     assert_equal ['', 'abcde'],     'abcde'.split_by_index(0)         
+     assert_equal ['e', 'abcd'],     'abcde'.split_by_index(-1)    
+     assert_equal ['de', 'abc'],     'abcde'.split_by_index(-2)    
+     assert_equal ['cde', 'ab'],     'abcde'.split_by_index(-3)    
+     assert_equal ['bcde', 'a'],     'abcde'.split_by_index(-4)    
+     assert_equal ['abcde', ''],     'abcde'.split_by_index(-5)    
+     assert_equal ['abcde', ''],     'abcde'.split_by_index(-100)    
+     
+     assert_equal ['', '', 'abcde'],  'abcde'.split_by_index([0,0])      
+     assert_equal ['', 'a', 'bcde'],  'abcde'.split_by_index([0,1])      
+     assert_equal ['', 'ab', 'cde'],  'abcde'.split_by_index([0,2])      
+     assert_equal ['', 'abc', 'de'],  'abcde'.split_by_index([0,3])      
+     assert_equal ['', 'abcd', 'e'],  'abcde'.split_by_index([0,4])      
+     assert_equal ['', 'abcde', ''],  'abcde'.split_by_index([0,5])       
+     assert_equal ['', 'abcde', ''],  'abcde'.split_by_index([0,100])       
+     
+     assert_equal ['a', '', 'bcde'],  'abcde'.split_by_index([1,0])      
+     assert_equal ['a', 'b', 'cde'],  'abcde'.split_by_index([1,1])      
+     assert_equal ['a', 'bc', 'de'],  'abcde'.split_by_index([1,2])      
+     assert_equal ['a', 'bcd', 'e'],  'abcde'.split_by_index([1,3])      
+     assert_equal ['a', 'bcde', ''],  'abcde'.split_by_index([1,4])           
+     assert_equal ['a', 'bcde', ''],  'abcde'.split_by_index([1,100])      
+     
+     assert_equal ['ab', '', 'cde'],  'abcde'.split_by_index([2,0])      
+     assert_equal ['ab', 'c', 'de'],  'abcde'.split_by_index([2,1])      
+     assert_equal ['ab', 'cd', 'e'],  'abcde'.split_by_index([2,2])      
+     assert_equal ['ab', 'cde', ''],  'abcde'.split_by_index([2,3])      
+     assert_equal ['ab', 'cde', ''],  'abcde'.split_by_index([2,100])      
+     
+     assert_equal ['', '', '', 'abcde'],  'abcde'.split_by_index([0,0,0])        
+     assert_equal ['', 'abcde', '', ''],  'abcde'.split_by_index([0,100,0])        
+     assert_equal ['', '', 'abcde', ''],  'abcde'.split_by_index([0,0,100])        
+  end  
+  
+  
+  def test_cut
+  	assert_equal 'Hal', 'Hallo'.cut(3)
+  	assert_equal 'Hallo', 'Hallo'.cut(5)
+  	assert_equal 'Hallo', 'Hallo'.cut(99)
+  	
+  	assert_equal '', 'Hallo'.cut(0)
+  	assert_equal '', ''.cut(0)
+  	assert_equal '', ''.cut(99)
+  	assert_equal '', nil.cut(0)
+  	assert_equal '', nil.cut(5)
+  end  
+  
+  
+  def test_fixsize
+    test = 'Hallo'
+    0.upto(10) do |i|
+      assert_equal i,    test.fixsize(i).size
+    end
+    -10.upto(0) do |i|
+      assert_equal 0,    test.fixsize(i).size
+    end
+  end
+    
+    
+  def test_split_numeric
+    assert_equal nil,                 nil.split_numeric
+    assert_equal ['abc',123],         'abc123'.split_numeric
+    assert_equal [' abc',123],        ' abc123'.split_numeric
+    assert_equal ['abc ',123],        'abc 123'.split_numeric
+    assert_equal [123,'abc'],         '123abc'.split_numeric
+    assert_equal [123,'abc '],        '123abc '.split_numeric
+    assert_equal [123,' abc'],        '123 abc'.split_numeric
+    
+    assert_equal 123,                 '123'.split_numeric
+    assert_equal 'abc',               'abc'.split_numeric
+    
+    assert_equal [123,'abc',456],     '123abc456'.split_numeric    
+    assert_equal ['abc',123,'def'],   'abc123def'.split_numeric 
+  end    
+  
+  
+  def test_without_versioninfo
+    assert_equal 'Hallo',   'Hallo_123.23'.without_versioninfo
+    assert_equal 'Hallo',   'Hallo-123.23'.without_versioninfo
+    assert_equal 'Hallo',   'Hallo 123.23'.without_versioninfo
+    assert_equal 'Hallo',   'Hallo123.23'.without_versioninfo
+    assert_equal 'Hallo',   'Hallo123_23'.without_versioninfo
+    assert_equal 'Hallo',   'Hallo.123_23'.without_versioninfo
+    assert_equal 'Hallo-Welt',   'Hallo-Welt_123.23'.without_versioninfo
+    assert_equal 'Hallo-Welt',   'Hallo-Welt-123.23'.without_versioninfo
+    assert_equal 'Hallo-Welt',   'Hallo-Welt 123.23'.without_versioninfo
+    assert_equal 'Hallo-Welt',   'Hallo-Welt123.23'.without_versioninfo
+    assert_equal 'Hallo-Welt',   'Hallo-Welt123_23'.without_versioninfo    
+    assert_equal 'Hallo-Welt',   'Hallo-Welt.123_23'.without_versioninfo    
+    assert_equal 'Hallo_Baum',   'Hallo_Baum_123.23'.without_versioninfo
+    assert_equal 'Hallo_Baum',   'Hallo_Baum-123.23'.without_versioninfo
+    assert_equal 'Hallo_Baum',   'Hallo_Baum 123.23'.without_versioninfo
+    assert_equal 'Hallo_Baum',   'Hallo_Baum123.23'.without_versioninfo
+    assert_equal 'Hallo_Baum',   'Hallo_Baum123_23'.without_versioninfo    
+    assert_equal 'Hallo_Baum',   'Hallo_Baum.123_23'.without_versioninfo 
+  end    
+    
+    
+end # class
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

data/test/test_dictionary.rb

@@ -0,0 +1,128 @@
+
+require 'kyanite/unit_test'
+require 'kyanite/smart_load_path'; smart_load_path
+require 'perception'                                if $0 == __FILE__                   
+                 
+require 'kyanite/dictionary'
+
+class TestKyaniteDictionary < UnitTest
+
+    def test_is_collection
+      assert Dictionary[1,2,3,4].is_collection?
+    end
+    
+    
+    def test_to_dictionary
+      test = {  :a => 1, 
+                :b => 2,
+                :c => 3  }
+      dict = test.to_dictionary
+      assert_equal 3,    dict.size
+      assert_equal 1,    dict[:a]
+      assert_equal 2,    dict[:b]
+      assert_equal 3,    dict[:c]
+    end
+    
+
+    
+    
+    def test_each
+      test = Dictionary[ 'a', 1, 'b', 2, 'c', 3 ]
+      test.each do | k, v|
+        assert_equal String, k.class
+        assert_equal Fixnum, v.class
+      end
+      
+      test.each_with_index do | k, v, i|
+        assert_equal String, k.class
+        assert_equal Fixnum, v.class
+        assert_equal Fixnum, i.class
+      end
+        
+    end
+
+    
+    def test_create 
+      hsh = Dictionary['z', 1, 'a', 2, 'c', 3] 
+      assert_equal( ['z','a','c'], hsh.keys )
+    end
+
+    
+    def test_op_store
+      hsh = Dictionary.new
+      hsh['z'] = 1
+      hsh['a'] = 2
+      hsh['c'] = 3
+      assert_equal( ['z','a','c'], hsh.keys )
+    end
+
+    
+    def test_push
+      hsh = Dictionary['a', 1, 'c', 2, 'z', 3]
+      assert( hsh.push('end', 15) )
+      assert_equal( 15, hsh['end'] )
+      assert( ! hsh.push('end', 30) )
+      assert( hsh.unshift('begin', 50) )
+      assert_equal( 50, hsh['begin'] )
+      assert( ! hsh.unshift('begin', 60) )
+      assert_equal( ["begin", "a", "c", "z", "end"], hsh.keys )
+      assert_equal( ["end", 15], hsh.pop )
+      assert_equal( ["begin", "a", "c", "z"], hsh.keys )
+      assert_equal( ["begin", 50], hsh.shift )
+    end
+
+    
+    def test_insert
+      # front
+      h = Dictionary['a', 1, 'b', 2, 'c', 3]
+      r = Dictionary['d', 4, 'a', 1, 'b', 2, 'c', 3]
+      assert_equal( 4, h.insert(0,'d',4) )
+      assert_equal( r, h )
+      # back
+      h = Dictionary['a', 1, 'b', 2, 'c', 3]
+      r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
+      assert_equal( 4, h.insert(-1,'d',4) )
+      assert_equal( r, h )
+    end
+
+    
+    def test_update
+      # with other orderred hash
+      h1 = Dictionary['a', 1, 'b', 2, 'c', 3]
+      h2 = Dictionary['d', 4]
+      r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
+      assert_equal( r, h1.update(h2) )
+      assert_equal( r, h1 )
+      # with other hash
+      h1 = Dictionary['a', 1, 'b', 2, 'c', 3]
+      h2 = { 'd' => 4 }
+      r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
+      assert_equal( r, h1.update(h2) )
+      assert_equal( r, h1 )
+    end
+
+    
+    def test_merge
+      # with other orderred hash
+      h1 = Dictionary['a', 1, 'b', 2, 'c', 3]
+      h2 = Dictionary['d', 4]
+      r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
+      assert_equal( r, h1.merge(h2) )
+      # with other hash
+      h1 = Dictionary['a', 1, 'b', 2, 'c', 3]
+      h2 = { 'd' => 4 }
+      r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
+      assert_equal( r, h1.merge(h2) )
+    end
+
+    
+    def test_order_by
+      h1 = Dictionary['a', 3, 'b', 2, 'c', 1]
+      h1.order_by{ |k,v| v }
+      assert_equal( [1,2,3], h1.values )
+      assert_equal( ['c','b','a'], h1.keys )
+    end
+
+end
+
+

data/test/test_hash.rb

@@ -0,0 +1,59 @@
+
+require 'kyanite/unit_test'
+require 'kyanite/smart_load_path'; smart_load_path
+require 'perception'                                if $0 == __FILE__                   
+                 
+require 'kyanite/hash'
+
+class TestKyaniteHash < UnitTest
+
+  
+  # Rubys +delete+ ver�ndert den Hash!
+  def test_delete
+    h = {}
+    assert_equal ({}),            h
+    
+    h[1] = 10
+    assert_equal ({ 1 => 10 }),   h    
+
+    h.delete(1)
+    assert_equal ({}),            h
+  end 
+  
+  
+  def test_compact
+    dirty_hash = ({     :a => 1, 
+                        :b => nil, 
+                        :c => nil, 
+                        :d => '', 
+                        nil => 3    })
+                       
+              
+    assert_equal 5, dirty_hash.size
+    assert_equal 4, dirty_hash.dup.compact_keys!.size    
+    assert_equal 3, dirty_hash.dup.compact_values!.size        
+    
+    dirty_hash.compact_keys!
+    assert_equal 4, dirty_hash.size      
+    
+    dirty_hash.compact_values!
+    assert_equal 2, dirty_hash.size   
+  end 
+  
+  
+  def test_slice
+    dirty_hash = ({     :a => 1, 
+                        :b => nil, 
+                        :c => nil, 
+                        :d => ''  })  
+                        
+    sliced = dirty_hash.slice(:b, :c)
+    assert ! sliced.has_key?(:a)
+    assert   sliced.has_key?(:b)
+    assert   sliced.has_key?(:c)
+    assert ! sliced.has_key?(:d)
+    
+  end
+  
+
+end # class 

data/test/test_optimizer.rb

@@ -0,0 +1,150 @@
+
+require 'kyanite/unit_test'
+require 'kyanite/smart_load_path'; smart_load_path
+require 'perception'                                if $0 == __FILE__    
+
+require 'kyanite/optimizer' 
+
+
+
+class TestKyaniteOptimizer <  UnitTest
+
+  
+  def test_basics
+    test = Optimizer.new
+    test.push  1,  'hallo'
+    test.push  5,  'eintrag'
+    test.push  6,  'maximum'
+    test.push -1,  'minimum'
+    test.push -1,  'noch ein minimum'  
+    test.push  6,  'noch ein maximum'    
+    test.push  0,   'blubb'
+    assert_equal 'minimum',                     test.content_min
+    assert_equal  -1,                           test.matchpoints_min
+    assert_equal 'maximum',                     test.content_max
+    assert_equal  6,                            test.matchpoints_max   
+    
+    assert_equal true,                          test.delete_min
+    assert_equal 'blubb',                       test.content_min
+    assert_equal  0,                            test.matchpoints_min 
+    assert_equal 'maximum',                     test.content_max
+    assert_equal  6,                            test.matchpoints_max   
+    
+    assert_equal true,                          test.delete_max
+    assert_equal 'eintrag',                     test.content_max
+    assert_equal  5,                            test.matchpoints_max
+    assert_equal 'blubb',                       test.content_min
+    assert_equal  0,                            test.matchpoints_min 
+    test.push  6,  'maximum'
+    assert_equal 'maximum',                     test.content_max
+    assert_equal  6,                            test.matchpoints_max       
+  end
+  
+  
+  
+  def test_range
+    test = Optimizer.new
+    test.push 1,   'hallo'
+    test.push 5,   'eintrag'
+    test.push 6,   'maximum'
+    test.push -1,  'minimum'
+    test.push -1,  'noch ein minimum'  
+    test.push  6,  'noch ein maximum'    
+    test.push 0,   'blubb'
+    assert_equal 'minimum',                     test.content_min(0..0)
+    assert_equal 'minimum',                     test.content_min(0)
+    assert_equal 'noch ein minimum',            test.content_min(1..1)
+    assert_equal 'noch ein minimum',            test.content_min(1)
+    assert_equal ['minimum', 
+                  'noch ein minimum'],          test.content_min(0..-1)
+    assert_equal  -1,                           test.matchpoints_min
+    assert_equal 'maximum',                     test.content_max(0..0)
+    assert_equal 'maximum',                     test.content_max(0)
+    assert_equal 'noch ein maximum',            test.content_max(1..1)
+    assert_equal 'noch ein maximum',            test.content_max(1)
+    assert_equal ['maximum', 
+                  'noch ein maximum'],          test.content_max(0..1)
+    # assert_equal ['noch ein maximum',                   
+                  # 'maximum'],                   test.content_max(1..0)
+    assert_equal  6,                            test.matchpoints_max   
+  end  
+
+  
+  def test_leer
+    test = Optimizer.new
+    assert_equal nil,                           test.content_min
+    assert_equal nil,                           test.matchpoints_min 
+    assert_equal nil,                           test.content_max
+    assert_equal nil,                           test.matchpoints_max   
+  end   
+  
+  
+  def pppest_cleanup
+    test = Optimizer.new
+    assert_equal false,                         test.cleanup!    
+    assert_equal 0,                             test.size  
+    test.push  1,  'hallo'
+    assert_equal false,                         test.cleanup!
+    assert_equal 1,                             test.size      
+    test.push  5,  'eintrag'
+    assert_equal false,                         test.cleanup! 
+    assert_equal 2,                             test.size  
+    test.push  6,  'maximum'
+    assert_equal true,                          test.cleanup! 
+    assert_equal 2,                             test.size  
+    test.push -1,  'minimum'
+    assert_equal true,                          test.cleanup! 
+    assert_equal 2,                             test.size      
+    test.push -1,  'noch ein minimum'
+    assert_equal false,                         test.cleanup!      
+    assert_equal 2,                             test.size      
+    test.push  0,  'blubb'
+    assert_equal true,                          test.cleanup!
+    assert_equal 2,                             test.size      
+    test.push  6,  'noch ein maximum'
+    assert_equal false,                         test.cleanup! 
+    assert_equal 2,                             test.size      
+    
+    assert_equal 'minimum',                     test.content_min[0]
+    assert_equal  -1,                           test.matchpoints_min
+    assert_equal 'maximum',                     test.content_max[0]
+    assert_equal  6,                            test.matchpoints_max       
+  end
+
+ 
+    
+    
+end # class
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+