distributed-trie 0.8.0

data/test/bigdata_spec.rb

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+# -*- encoding: utf-8 -*-
+#
+# bigdata_spec.rb -  "RSpec file for bigdata test-case"
+#
+#   Copyright (c) 2012     Kiyoka Nishiyama  <kiyoka@sumibi.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. Neither the name of the authors nor the names of its contributors
+#      may be used to endorse or promote products derived from this
+#      software without specific prior written permission.
+#
+#   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+#   "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 COPYRIGHT
+#   OWNER OR CONTRIBUTORS 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.
+#
+require 'distributedtrie'
+include DistributedTrie
+
+
+describe Trie, "when initialized as '()" do
+  before do
+    @kvs  = DistributedTrie::KvsIf.new
+    @trie = Trie.new( @kvs, "TEST::" )
+    @arr = "0123456789abcdefghijklmnopqrstuvwxyz".split(//)
+  end
+
+  it "should" do
+    @arr.each { |s1|
+      @arr.each { |s2|
+        @arr.each { |s3|
+          @trie.addKey!( s1+s2+s3 )
+        }
+      }
+    }
+
+    @trie.addKey!( "0" )
+    @trie.addKey!( "1" )
+    @trie.addKey!( "AA" )
+    @trie.addKey!( "BB" )
+
+    @trie._getInternal( :work ).size.should == 1335
+    @trie.commit!()
+
+    @trie.exactMatchSearch( "0" ).should           == ["0"]
+    @trie.exactMatchSearch( "1" ).should           == ["1"]
+    @trie.exactMatchSearch( "2" ).should           == []
+    @trie.exactMatchSearch( "AA" ).should          == ["AA"]
+    @trie.exactMatchSearch( "BB" ).should          == ["BB"]
+    @trie.exactMatchSearch( "CC" ).should          == []
+    @trie.exactMatchSearch( "aa" ).should          == []
+    @trie.exactMatchSearch( "bb" ).should          == []
+    @trie.exactMatchSearch( "aaa" ).should         == ["aaa"]
+    @trie.exactMatchSearch( "aaa" ).should         == ["aaa"]
+    @trie.exactMatchSearch( "zzz" ).should         == ["zzz"]
+    @trie.exactMatchSearch( "012" ).should         == ["012"]
+
+    @trie.commonPrefixSearch( '00' ).should        == @arr.map{ |x| "00" + x }
+    @trie.commonPrefixSearch( '' ).size.should     == (@arr.size * @arr.size * @arr.size) + 4
+    @trie.search( 'ab'  ){|x| ( 'aba'  <= x) && (x <=   'abe') }.should      == ["aba", "abb", "abc", "abd", "abe"]
+    @trie.search( 'zz'  ){|x| x.match( /zz[7-9]/ )  }.should                 == ["zz7", "zz8", "zz9"]
+
+    @trie.search( ''    ){|x| 1 == x.size }.should                           == ["0", "1"]
+    @trie.search( ''    ){|x| 2 >= x.size }.should                           == ["0", "1", "AA", "BB"]
+
+  end
+end

data/test/internal_spec.rb

@@ -0,0 +1,241 @@
+#!/usr/bin/env ruby
+# -*- encoding: utf-8 -*-
+#
+# internal_spec.rb -  "RSpec file for trie internal hehavior"
+#
+#   Copyright (c) 2012     Kiyoka Nishiyama  <kiyoka@sumibi.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. Neither the name of the authors nor the names of its contributors
+#      may be used to endorse or promote products derived from this
+#      software without specific prior written permission.
+#
+#   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+#   "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 COPYRIGHT
+#   OWNER OR CONTRIBUTORS 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.
+#
+require 'distributedtrie'
+include DistributedTrie
+
+describe Trie, "Ruby version " do
+  it "should" do
+    RUBY_VERSION.match( /^1[.]8/ ).should_not be_true
+  end
+end
+
+describe Trie, "when _mergeIndex is called " do
+  before do
+    @kvs  = DistributedTrie::KvsIf.new
+    @trie = Trie.new( @kvs, "TEST::" )
+  end
+  it "should" do
+    @trie._mergeIndex( "a$ a" ).should                         == "a$"
+    @trie._mergeIndex( " a$"  ).should                         == "a$"
+    @trie._mergeIndex( "a$ b" ).should                         == "a$ b"
+    @trie._mergeIndex( "a$ a$ a$   a$" ).should                == "a$"
+    @trie._mergeIndex( "a$ a a   a a a    a   a" ).should      == "a$"
+    @trie._mergeIndex( "b b b b   b b  ").should               == "b"
+    @trie._mergeIndex( "a b c d e f g" ).should                == "a b c d e f g"
+    @trie._mergeIndex( "a$ b c$ d e$ f g$" ).should            == "a$ c$ e$ g$ b d f"
+  end
+end
+
+describe Trie, "when _createTree is called " do
+  before do
+    @kvs  = DistributedTrie::KvsIf.new
+    @trie = Trie.new( @kvs, "TEST::" )
+  end
+
+  it "should" do
+    @trie.addKey!( "a" )
+    @trie._getInternal( :work ).should == { '' => 'a$' }
+    @trie.addKey!( "ab" )
+    @trie._getInternal( :work ).should == { '' => 'a$', 'a' => 'b$' }
+    @trie.addKey!( "in" )
+    @trie._getInternal( :work ).should == { '' => 'a$ i', 'a' => 'b$', 'i' => 'n$' }
+  end
+end
+
+describe Trie, "when _commit is called " do
+  before do
+    @kvs  = DistributedTrie::KvsIf.new
+    @trie = Trie.new( @kvs, "TEST::" )
+  end
+
+  it "should" do
+    @trie.addKey!( "app" )
+    @trie._getInternal( :work ).should == { ""=>"a", "a"=>"p", "ap"=>"p$" }
+    @trie.addKey!( "apple" )
+    @trie._getInternal( :work ).should == { ""=>"a", "a"=>"p", "ap"=>"p$", "app"=>"l", "appl"=>"e$" }
+    @trie.addKey!( "application" )
+    @trie._getInternal( :work ).should == { ""=>"a", "a"=>"p", "ap"=>"p$", "app"=>"l", "appl"=>"e$ i", "appli"=>"c", "applic"=>"a", "applica"=>"t", "applicat"=>"i", "applicati"=>"o", "applicatio"=>"n$" }
+    @trie.commit!()
+    @trie._getInternal( :work ).should == {}
+    @kvs._getInternal( ).should        == [
+      ["TEST::", "a"],
+      ["TEST::a", "p"],
+      ["TEST::ap", "p$"],
+      ["TEST::app", "l"],
+      ["TEST::appl", "e$ i"],
+      ["TEST::appli", "c"],
+      ["TEST::applic", "a"],
+      ["TEST::applica", "t"],
+      ["TEST::applicat", "i"],
+      ["TEST::applicati", "o"],
+      ["TEST::applicatio", "n$"]]
+    @trie.listChilds( "" ).should                == ["app", "apple", "application"]
+    @trie.listChilds( "ap" ).should              == ["app", "apple", "application"]
+    @trie.listChilds( "app" ).should             == [       "apple", "application"]
+    @trie.listChilds( "appl" ).should            == [       "apple", "application"]
+    @trie.listChilds( "appli" ).should           == [                "application"]
+
+    @trie.exactMatchSearch( "" ).should          == []
+    @trie.exactMatchSearch( "ap" ).should        == []
+    @trie.exactMatchSearch( "app" ).should       == ["app"]
+    @trie.exactMatchSearch( "appl" ).should      == []
+    @trie.exactMatchSearch( "appli" ).should     == []
+    @trie.exactMatchSearch( "apple" ).should     == ["apple"]
+
+    @trie.commonPrefixSearch( "" ).should        == ["app", "apple", "application"]
+    @trie.commonPrefixSearch( "ap" ).should      == ["app", "apple", "application"]
+    @trie.commonPrefixSearch( "app" ).should     == ["app", "apple", "application"]
+    @trie.commonPrefixSearch( "appl" ).should    == [       "apple", "application"]
+    @trie.commonPrefixSearch( "appli" ).should   == [                "application"]
+  end
+end
+
+
+describe Trie, "when api methods are called " do
+  before do
+    @kvs  = DistributedTrie::KvsIf.new
+    @trie = Trie.new( @kvs, "TEST::" )
+  end
+
+  it "should" do
+    @trie.addKey!( "i" )
+    @trie._getInternal( :work ).should == { ""=>"i$" }
+    @trie.addKey!( "in" )
+    @trie._getInternal( :work ).should == { ""=>"i$", "i"=>"n$" }
+    @trie.addKey!( "ab1" )
+    @trie._getInternal( :work ).should == { ""=>"i$ a", "i"=>"n$", "a"=>"b", "ab"=>"1$" }
+    @trie.addKey!( "ab2" )
+    @trie._getInternal( :work ).should == { ""=>"i$ a", "i"=>"n$", "a"=>"b", "ab"=>"1$ 2$" }
+    @trie.addKey!( "ab3" )
+    @trie._getInternal( :work ).should == { ""=>"i$ a", "i"=>"n$", "a"=>"b", "ab"=>"1$ 2$ 3$" }
+    @trie.addKey!( "abc4" )
+    @trie._getInternal( :work ).should == { ""=>"i$ a", "i"=>"n$", "a"=>"b", "ab"=>"1$ 2$ 3$ c", "abc"=>"4$" }
+    @trie.commit!()
+    @trie._getInternal( :work ).should == {}
+    @kvs._getInternal( ).should        == [
+      ["TEST::", "i$ a"],
+      ["TEST::i", "n$"],
+      ["TEST::a", "b"],
+      ["TEST::ab", "1$ 2$ 3$ c"],
+      ["TEST::abc", "4$"]]
+    @trie.exactMatchSearch( "" ).should         == []
+    @trie.exactMatchSearch( "a" ).should        == []
+    @trie.exactMatchSearch( "ab1" ).should      == ["ab1"]
+    @trie.exactMatchSearch( "ab3" ).should      == ["ab3"]
+    @trie.exactMatchSearch( "xxx" ).should      == []
+    @trie.exactMatchSearch( "abc4" ).should     == ["abc4"]
+    @trie.exactMatchSearch( "abc4A" ).should    == []
+
+    @trie.search( '' )    {|x| x.size == 0}.should      == []
+    @trie.search( '' )    {|x| x.size == 1}.should      == ["i"]
+    @trie.search( '' )    {|x| x.size <= 2}.should      == ["in", "i"]
+    @trie.search( '' )    {|x| x.size  < 4}.should      == ["in", "i", "ab1", "ab2", "ab3"]
+    @trie.search( 'ab' )  {|x| true}.should             == ["ab1", "ab2", "ab3", "abc4"]
+    @trie.commonPrefixSearch( 'ab' ).should             == ["ab1", "ab2", "ab3", "abc4"]
+    @trie.commonPrefixSearch( 'i' ).should              == ["i", "in"]
+    @trie.commonPrefixSearch( 'in' ).should             == ["in"]
+
+    @trie.search( ''      ){|x| x == "ab1" }.should                        == []
+    @trie.search( 'ab'    ){|x| x == "ab1" }.should                        == ["ab1"]
+    @trie.search( 'ab'    ){|x| ( 'ab1' < x) && (x < 'ab4') }.should       == ["ab2", "ab3"]
+    @trie.search( ''      ){|x| ( '0' < x) && (x < 'z') }.should           == ["in", "i", "ab1", "ab2", "ab3", "abc4"]
+
+    @trie.search( ''      ){|x| ( 'a'  <= x) && (x <    'b') }.should      == ["ab1", "ab2", "ab3", "abc4"]
+
+    @trie.rangeSearch( 'ab1', 'ab3' ).should           == ["ab1", "ab2", "ab3"]
+    @trie.rangeSearch( 'ab2', 'abd' ).should           == ["ab2", "ab3", "abc4"]
+  end
+end
+
+
+describe Trie, "when commit! are called " do
+  before do
+    @kvs  = DistributedTrie::KvsIf.new
+    @trie = Trie.new( @kvs, "TEST::" )
+  end
+
+  it "should" do
+    @trie.addKey!( "a" )
+    @trie._getInternal( :work ).should     == { ""=>"a$" }
+    @kvs._getInternal( ).should            == []
+    @trie.commit!
+    @trie._getInternal( :work ).should     == {}
+    @kvs._getInternal( ).should            == [[ "TEST::", "a$" ]]
+
+    @trie.addKey!( "b" )
+    @trie._getInternal( :work ).should     == { ""=>"b$" }
+    @kvs._getInternal( ).should            == [[ "TEST::", "a$" ]]
+    @trie.commit!
+    @trie._getInternal( :work ).should     == {}
+    @kvs._getInternal( ).should            == [[ "TEST::", "a$ b$" ]]
+
+    @trie.addKey!( "a" )
+    @trie.addKey!( "b" )
+    @trie._getInternal( :work ).should     == { ""=>"a$ b$" }
+    @kvs._getInternal( ).should            == [[ "TEST::", "a$ b$" ]]
+    @trie.commit!
+    @trie._getInternal( :work ).should     == {}
+    @kvs._getInternal( ).should            == [[ "TEST::", "a$ b$" ]]
+
+    @trie.addKey!( "01234" )
+    @trie._getInternal( :work ).should     == {""=>"0", "0"=>"1", "01"=>"2", "012"=>"3", "0123"=>"4$"}
+    @kvs._getInternal( ).should            == [[ "TEST::", "a$ b$" ]]
+    @trie.commit!
+    @trie._getInternal( :work ).should     == {}
+    @kvs._getInternal( ).should            == [
+      ["TEST::", "a$ b$ 0"],
+      ["TEST::0", "1"],
+      ["TEST::01", "2"],
+      ["TEST::012", "3"],
+      ["TEST::0123", "4$"]]
+
+    @trie.addKey!( "0123Z" )
+    @trie._getInternal( :work ).should     == {""=>"0", "0"=>"1", "01"=>"2", "012"=>"3", "0123"=>"Z$"}
+    @kvs._getInternal( ).should            == [
+      ["TEST::", "a$ b$ 0"],
+      ["TEST::0", "1"],
+      ["TEST::01", "2"],
+      ["TEST::012", "3"],
+      ["TEST::0123", "4$"]]
+    @trie.commit!
+    @trie._getInternal( :work ).should     == {}
+    @kvs._getInternal( ).should            == [
+      ["TEST::", "a$ b$ 0"],
+      ["TEST::0", "1"],
+      ["TEST::01", "2"],
+      ["TEST::012", "3"],
+      ["TEST::0123", "4$ Z$"]]
+  end
+end

data/test/rspec_formatter_for_emacs.rb

@@ -0,0 +1,26 @@
+require 'rspec/core/formatters/progress_formatter'
+
+# Example of a formatter with custom bactrace printing. Run me with:
+# ruby bin/spec xxxxx.rb -r ./test/rspec_formatter_for_emacs.rb -f CustomFormatter
+class CustomFormatter < RSpec::Core::Formatters::ProgressFormatter
+  def backtrace_line(line)
+    return nil if configuration.cleaned_from_backtrace?(line)
+    str = line.gsub(/([^:]*\.rb):([0-9]+):in /) do
+      path   = "#{$1}"
+      lineno = "#{$2}"
+      if path.match( /lib/ ) and path.match( /rspec/ )
+        "#{File.expand_path(path)}:#{lineno} IN "
+      else
+        "#{File.expand_path(path)}:#{lineno}:in "
+      end
+    end
+    str
+  end
+
+  def dump_backtrace(example)
+    format_backtrace(example.execution_result[:exception].backtrace, example).each do |backtrace_info|
+      output.puts cyan("    #{backtrace_info}")
+    end
+  end
+
+end

data/test/usecase_spec.rb

@@ -0,0 +1,126 @@
+#!/usr/bin/env ruby
+# -*- encoding: utf-8 -*-
+#
+# usecase_spec.rb -  "RSpec file for ordinary usecase"
+#
+#   Copyright (c) 2012     Kiyoka Nishiyama  <kiyoka@sumibi.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. Neither the name of the authors nor the names of its contributors
+#      may be used to endorse or promote products derived from this
+#      software without specific prior written permission.
+#
+#   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+#   "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 COPYRIGHT
+#   OWNER OR CONTRIBUTORS 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.
+#
+require 'distributedtrie'
+include DistributedTrie
+
+describe Trie, "when you create auto complete application " do
+  before do
+    @kvs  = DistributedTrie::KvsIf.new
+    @trie = Trie.new( @kvs, "TEST::" )
+  end
+
+  it "should" do
+    @trie.addKey!( "i" )
+    @trie.addKey!( "in" )
+    @trie.addKey!( "inn" )
+    @trie.addKey!( "communication" )
+    @trie.addKey!( "command" )
+    @trie.addKey!( "come" )
+    @trie.addKey!( "coming" )
+    @trie.addKey!( "code" )
+    @trie.addKey!( "copy" )
+    @trie.addKey!( "copyright" )
+    @trie.commit!
+
+    @trie.commonPrefixSearch( "i" ).should       == ["i", "in", "inn"]
+    @trie.commonPrefixSearch( "in" ).should      == ["in", "inn"]
+    @trie.commonPrefixSearch( "c" ).should       == ["come", "communication", "command", "coming", "code", "copy", "copyright"]
+    @trie.commonPrefixSearch( "co" ).should      == ["come", "communication", "command", "coming", "code", "copy", "copyright"]
+    @trie.commonPrefixSearch( "comm" ).should    == ["communication", "command"]
+    @trie.commonPrefixSearch( "cod" ).should     == ["code"]
+    @trie.commonPrefixSearch( "cop" ).should     == ["copy", "copyright"]
+
+    @trie.exactMatchSearch( "copy" ).should      == ["copy"]
+  end
+end
+
+def _roundDistance( arr )
+  arr.map { |x|
+    val = x[0] * 1000
+    [ val.round / 1000.0, x[1] ]
+  }
+end
+
+describe Trie, "when you create fuzzy-string-search application " do
+  before do
+    @kvs   = DistributedTrie::KvsIf.new
+    @trie  = Trie.new( @kvs, "TEST::" )
+    @words = [
+              "communication",
+              "community",
+              "command",
+              "comedy",
+              "coming",
+              "code",
+              "copy",
+              "copyright"
+             ]
+    @words2 = [
+               "henkan",
+               "henkann",
+               "henka",
+               "hennka",
+               "henkaq",
+              ]
+  end
+
+  it "should" do
+    @words.each  { |word|  @trie.addKey!( word ) }
+    @words2.each { |word|  @trie.addKey!( word ) }
+    @trie.commit!
+
+    _roundDistance( @trie.fuzzySearch( "come"           )).should    == [[0.933, "comedy"]]
+    _roundDistance( @trie.fuzzySearch( "come",    0.85  )).should    == [[0.933, "comedy"], [0.867, "code"]]
+    _roundDistance( @trie.fuzzySearch( "come",    0.82  )).should    == [[0.933, "comedy"], [0.867, "code"], [0.825, "coming"]]
+    _roundDistance( @trie.fuzzySearch( "come",    0.80  )).should    == [[0.933, "comedy"], [0.867, "code"], [0.825, "coming"], [0.808, "command"]]
+
+    _roundDistance( @trie.fuzzySearch( "comm"                 )).should    == [[0.914, "command"]]
+    _roundDistance( @trie.fuzzySearch( "communication", 0.92  )).should    == [[1.0, "communication"], [0.924, "community"]]
+
+    _roundDistance( @trie.fuzzySearch( "copylight"            )).should    == [[0.956, "copyright"]]
+    _roundDistance( @trie.fuzzySearch( "copyrigh"     , 0.99  )).should    == [[0.993, "copyright"]]
+    _roundDistance( @trie.fuzzySearch( "copyleft"             )).should    == [[0.9, "copy"]]
+
+    _roundDistance( @trie.fuzzySearch( "henkan"       , 0.94  )).should    == [[1.0, "henkan"], [0.981, "henkann"], [0.972, "henka"], [0.944, "henkaq"]]
+
+    jarow = FuzzyStringMatch::JaroWinkler.create( )
+    @words.select  { |word| 0.85 <= jarow.getDistance( word, "come" )          }.should == ["comedy", "code"]
+    @words.select  { |word| 0.90 <= jarow.getDistance( word, "copylight" )     }.should == ["copyright"]
+    @words.select  { |word| 0.92 <= jarow.getDistance( word, "communication" ) }.should == ["communication", "community"]
+    @words.select  { |word| 0.90 <= jarow.getDistance( word, "copyleft" )      }.should == ["copy"]
+
+    @words2.select { |word| 0.94 <  jarow.getDistance( word, "henkan" )        }.should == ["henkan", "henkann", "henka", "hennka", "henkaq"]
+  end
+end